${dali_csharp_binder_dir}/src/application.cpp \
${dali_csharp_binder_dir}/src/text-editor.cpp \
${dali_csharp_binder_dir}/src/text-field.cpp \
+ ${dali_csharp_binder_dir}/src/transition-base.cpp \
+ ${dali_csharp_binder_dir}/src/transition.cpp \
+ ${dali_csharp_binder_dir}/src/transition-set.cpp \
${dali_csharp_binder_dir}/src/window.cpp \
${dali_csharp_binder_dir}/src/tts-player.cpp \
${dali_csharp_binder_dir}/src/input-method-context.cpp \
return mId;
}
-void LayoutController::Process()
+void LayoutController::Process(bool postProcessor)
{
if( handler )
{
/**
* @copydoc Dali::Integration::Processor::Process()
*/
- void Process() override;
+ void Process(bool postProcessor) override;
/**
* @brief Set the callback to be executed when dali-core calls the overriden Process() api.
--- /dev/null
+/*
+ * 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.
+ *
+ */
+
+#ifndef CSHARP_TRANSITION_BASE
+#define CSHARP_TRANSITION_BASE
+#endif
+
+#include <string.h>
+#include "common.h"
+#include <dali-toolkit/public-api/transition/transition-base.h>
+#include <dali/integration-api/debug.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define CALL_CATCH_EXCEPTION(ret) \
+ catch (std::out_of_range & e) \
+ { \
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what())); \
+ return ret; \
+ } \
+ catch (std::exception & e) \
+ { \
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what())); \
+ return ret; \
+ } \
+ catch (Dali::DaliException e) \
+ { \
+ SWIG_CSharpException(SWIG_UnknownError, e.condition); \
+ return ret; \
+ } \
+ catch (...) \
+ { \
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); \
+ return ret; \
+ }
+
+ 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_SetDuration(void *nuiTransitionBase, float nuiSeconds)
+ {
+ Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase;
+
+ if (!transition)
+ {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
+ return;
+ }
+ {
+ try
+ {
+ (transition)->SetDuration(nuiSeconds);
+ }
+ CALL_CATCH_EXCEPTION();
+ }
+ }
+
+ SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TransitionBase_GetDuration(void *nuiTransitionBase)
+ {
+ Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase;
+ float result;
+ {
+ try
+ {
+ result = (float)((Dali::Toolkit::TransitionBase const *)transition)->GetDuration();
+ }
+ CALL_CATCH_EXCEPTION(0);
+ }
+ return result;
+ }
+
+ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionBase_SetDelay(void *nuiTransitionBase, float nuiSeconds)
+ {
+ Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase;
+
+ if (!transition)
+ {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
+ return;
+ }
+ {
+ try
+ {
+ (transition)->SetDelay(nuiSeconds);
+ }
+ CALL_CATCH_EXCEPTION();
+ }
+ }
+
+ SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TransitionBase_GetDelay(void *nuiTransitionBase)
+ {
+ Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase;
+ float result;
+ {
+ try
+ {
+ result = (float)((Dali::Toolkit::TransitionBase const *)transition)->GetDelay();
+ }
+ CALL_CATCH_EXCEPTION(0);
+ }
+ return result;
+ }
+
+ 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_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();
+ }
+ }
+
+#ifdef __cplusplus
+}
+#endif
--- /dev/null
+/*
+ * 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.
+ *
+ */
+
+#ifndef CSHARP_TRANSITION_SET
+#define CSHARP_TRANSITION_SET
+#endif
+
+#include <string.h>
+#include "common.h"
+#include <dali-toolkit/public-api/transition/transition-set.h>
+#include <dali/integration-api/debug.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
+
+#define CALL_CATCH_EXCEPTION(ret) \
+ catch (std::out_of_range& e) \
+ { \
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); \
+ return ret; \
+ } \
+ catch (std::exception& e) \
+ { \
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); \
+ return ret; \
+ } \
+ catch (Dali::DaliException e) \
+ { \
+ SWIG_CSharpException(SWIG_UnknownError, e.condition); \
+ return ret; \
+ } \
+ catch (...) \
+ { \
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); \
+ return ret; \
+ }
+
+
+
+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;CSHARP_TRANSITION_SET
+ 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;
+ Dali::Toolkit::TransitionSet::TransitionSetSignalType* transitionSetSignalType = (Dali::Toolkit::TransitionSet::TransitionSetSignalType*)0;
+ 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;
+ Dali::Toolkit::TransitionSet::TransitionSetSignalType* transitionSetSignalType = (Dali::Toolkit::TransitionSet::TransitionSetSignalType*)0;
+ 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;
+ Dali::Toolkit::TransitionSet::TransitionSetSignalType* transitionSetSignalType = (Dali::Toolkit::TransitionSet::TransitionSetSignalType*)0;
+ {
+ 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;
+ Dali::Toolkit::TransitionSet::TransitionSetSignalType* transitionSetSignalType = (Dali::Toolkit::TransitionSet::TransitionSetSignalType*)0;
+ {
+ try {
+ Dali_TransitionSet_Signal_Disconnect((Dali::Toolkit::TransitionSet::TransitionSetSignalType*)transitionSet, func);
+ }CALL_CATCH_EXCEPTION();
+ }
+}
+
+#ifdef __cplusplus
+}
+#endif
--- /dev/null
+/*
+ * 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.
+ *
+ */
+
+#ifndef CSHARP_TRANSITION
+#define CSHARP_TRANSITION
+#endif
+
+#include <string.h>
+#include "common.h"
+#include <dali-toolkit/public-api/transition/transition.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define CALL_CATCH_EXCEPTION(ret) \
+ catch (std::out_of_range & e) \
+ { \
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what())); \
+ return ret; \
+ } \
+ catch (std::exception & e) \
+ { \
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what())); \
+ return ret; \
+ } \
+ catch (Dali::DaliException e) \
+ { \
+ SWIG_CSharpException(SWIG_UnknownError, e.condition); \
+ return ret; \
+ } \
+ catch (...) \
+ { \
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); \
+ return ret; \
+ }
+
+ 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, 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, *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;
+ }
+
+ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Transition_ShowSourceAfterFinished(void *nuiTransitionBase, bool nuiShowSourceAfterFinished)
+ {
+ Dali::Toolkit::Transition *transition = (Dali::Toolkit::Transition *)nuiTransitionBase;
+
+ if (!transition)
+ {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
+ return;
+ }
+ {
+ try
+ {
+ (transition)->ShowSourceAfterFinished(nuiShowSourceAfterFinished);
+ }
+ CALL_CATCH_EXCEPTION();
+ }
+ }
+
+#ifdef __cplusplus
+}
+#endif
projects / platform / core / uifw / dali-csharp-binder.git / commitdiff