From: Joogab Yun Date: Tue, 20 Apr 2021 01:06:51 +0000 (+0900) Subject: [Tizen] Adds transition effect X-Git-Tag: accepted/tizen/unified/20210422.090553~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=cab3ac1d1b34d5b1eaa7e1d6ac3f1e7e93f163b2;p=platform%2Fcore%2Fuifw%2Fdali-csharp-binder.git [Tizen] Adds transition effect This reverts commit 2002872653be9d06aaf1d1767e935721c91c9598. Change-Id: I189b63649691c7190929803baba317202f7776e9 --- diff --git a/dali-csharp-binder/file.list b/dali-csharp-binder/file.list index 3e124ba..c89c6c0 100755 --- a/dali-csharp-binder/file.list +++ b/dali-csharp-binder/file.list @@ -21,6 +21,9 @@ dali_csharp_binder_common_src_files = \ ${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 \ diff --git a/dali-csharp-binder/src/layout-controller.cpp b/dali-csharp-binder/src/layout-controller.cpp index c7b9bb0..042150c 100644 --- a/dali-csharp-binder/src/layout-controller.cpp +++ b/dali-csharp-binder/src/layout-controller.cpp @@ -44,7 +44,7 @@ int LayoutController::GetId() const return mId; } -void LayoutController::Process() +void LayoutController::Process(bool postProcessor) { if( handler ) { diff --git a/dali-csharp-binder/src/layout-controller.h b/dali-csharp-binder/src/layout-controller.h index a3fff0d..162e1e2 100644 --- a/dali-csharp-binder/src/layout-controller.h +++ b/dali-csharp-binder/src/layout-controller.h @@ -55,7 +55,7 @@ public: /** * @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. diff --git a/dali-csharp-binder/src/transition-base.cpp b/dali-csharp-binder/src/transition-base.cpp new file mode 100755 index 0000000..3375e8f --- /dev/null +++ b/dali-csharp-binder/src/transition-base.cpp @@ -0,0 +1,286 @@ +/* + * 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 +#include "common.h" +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +#define CALL_CATCH_EXCEPTION(ret) \ + catch (std::out_of_range & e) \ + { \ + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); \ + return ret; \ + } \ + catch (std::exception & e) \ + { \ + SWIG_CSharpException(SWIG_RuntimeError, const_cast(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 diff --git a/dali-csharp-binder/src/transition-set.cpp b/dali-csharp-binder/src/transition-set.cpp new file mode 100755 index 0000000..959ddb1 --- /dev/null +++ b/dali-csharp-binder/src/transition-set.cpp @@ -0,0 +1,284 @@ +/* + * 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 +#include "common.h" +#include +#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 + +#define CALL_CATCH_EXCEPTION(ret) \ + catch (std::out_of_range& e) \ + { \ + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); \ + return ret; \ + } \ + catch (std::exception& e) \ + { \ + SWIG_CSharpException(SWIG_RuntimeError, const_cast(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 diff --git a/dali-csharp-binder/src/transition.cpp b/dali-csharp-binder/src/transition.cpp new file mode 100755 index 0000000..254ced2 --- /dev/null +++ b/dali-csharp-binder/src/transition.cpp @@ -0,0 +1,173 @@ +/* + * 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 +#include "common.h" +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +#define CALL_CATCH_EXCEPTION(ret) \ + catch (std::out_of_range & e) \ + { \ + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); \ + return ret; \ + } \ + catch (std::exception & e) \ + { \ + SWIG_CSharpException(SWIG_RuntimeError, const_cast(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