From dabf343e8d372f0684f67e049f2bb60789453729 Mon Sep 17 00:00:00 2001 From: Muhammad Umar Date: Tue, 8 May 2018 15:05:14 +0100 Subject: [PATCH] Bindings for Layouting. Change-Id: Ie82888f00b4518cd5e00961cc0d1c2f85cb944a6 --- dali-csharp-binder/file.list | 18 + dali-csharp-binder/src/common.h | 4 +- dali-csharp-binder/src/dali_wrap.cpp | 142 +- dali-csharp-binder/src/dali_wrap.h | 1 - .../src/layout-group-wrapper-impl.cpp | 1282 +++++++++++++++++ dali-csharp-binder/src/layout-group-wrapper-impl.h | 110 ++ dali-csharp-binder/src/layout-group-wrapper.cpp | 457 ++++++ dali-csharp-binder/src/layout-item-ptr.cpp | 1311 +++++++++++++++++ .../src/layout-item-wrapper-impl.cpp | 1509 ++++++++++++++++++++ dali-csharp-binder/src/layout-item-wrapper-impl.h | 82 ++ dali-csharp-binder/src/layout-item-wrapper.cpp | 383 +++++ dali-csharp-binder/src/layout-length.cpp | 776 ++++++++++ dali-csharp-binder/src/layout-measure-spec.cpp | 356 +++++ dali-csharp-binder/src/layout-measured-size.cpp | 406 ++++++ dali-csharp-binder/src/layout-size.cpp | 444 ++++++ 15 files changed, 7275 insertions(+), 6 deletions(-) create mode 100755 dali-csharp-binder/src/layout-group-wrapper-impl.cpp create mode 100644 dali-csharp-binder/src/layout-group-wrapper-impl.h create mode 100755 dali-csharp-binder/src/layout-group-wrapper.cpp create mode 100755 dali-csharp-binder/src/layout-item-ptr.cpp create mode 100755 dali-csharp-binder/src/layout-item-wrapper-impl.cpp create mode 100644 dali-csharp-binder/src/layout-item-wrapper-impl.h create mode 100755 dali-csharp-binder/src/layout-item-wrapper.cpp create mode 100755 dali-csharp-binder/src/layout-length.cpp create mode 100755 dali-csharp-binder/src/layout-measure-spec.cpp create mode 100755 dali-csharp-binder/src/layout-measured-size.cpp create mode 100755 dali-csharp-binder/src/layout-size.cpp diff --git a/dali-csharp-binder/file.list b/dali-csharp-binder/file.list index 5345d9c..24efa88 100755 --- a/dali-csharp-binder/file.list +++ b/dali-csharp-binder/file.list @@ -8,6 +8,15 @@ dali_csharp_binder_src_files = \ src/keyboard_focus_manager_wrap.cpp \ src/devel-property-wrap.cpp \ src/version-check.cpp \ + src/layout-length.cpp \ + src/layout-size.cpp \ + src/layout-measured-size.cpp \ + src/layout-measure-spec.cpp \ + src/layout-item-ptr.cpp \ + src/layout-item-wrapper.cpp \ + src/layout-item-wrapper-impl.cpp \ + src/layout-group-wrapper.cpp \ + src/layout-group-wrapper-impl.cpp \ src/view-wrapper-impl-wrap.cpp \ src/event-thread-callback-wrap.cpp \ src/application.cpp \ @@ -29,6 +38,15 @@ dali_csharp_binder_src_files_tizen = \ src/keyboard_focus_manager_wrap.cpp \ src/devel-property-wrap.cpp \ src/version-check.cpp \ + src/layout-length.cpp \ + src/layout-size.cpp \ + src/layout-measured-size.cpp \ + src/layout-measure-spec.cpp \ + src/layout-item-ptr.cpp \ + src/layout-item-wrapper.cpp \ + src/layout-item-wrapper-impl.cpp \ + src/layout-group-wrapper.cpp \ + src/layout-group-wrapper-impl.cpp \ src/view-wrapper-impl-wrap.cpp \ src/event-thread-callback-wrap.cpp \ src/application.cpp \ diff --git a/dali-csharp-binder/src/common.h b/dali-csharp-binder/src/common.h index 2418cf4..1a277ff 100755 --- a/dali-csharp-binder/src/common.h +++ b/dali-csharp-binder/src/common.h @@ -2,7 +2,7 @@ #define CSHARP_COMMON_H /* - * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * 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. @@ -131,6 +131,7 @@ typedef enum 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 { @@ -165,5 +166,6 @@ extern void SWIG_CSharpException(int code, const char *msg); #include #include +#include #endif // CSHARP_COMMON_H diff --git a/dali-csharp-binder/src/dali_wrap.cpp b/dali-csharp-binder/src/dali_wrap.cpp index cf037b4..4965b8b 100755 --- a/dali-csharp-binder/src/dali_wrap.cpp +++ b/dali-csharp-binder/src/dali_wrap.cpp @@ -14,7 +14,6 @@ #define SWIG_DIRECTORS - #ifdef __cplusplus /* SwigValueWrapper is described in swig.swg */ template class SwigValueWrapper { @@ -167,7 +166,6 @@ template T SwigValueInit() { #include #include - /* 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 { @@ -32706,7 +32704,6 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) { } - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) { Dali::Actor arg1 ; Dali::Actor arg2 ; @@ -62705,7 +62702,6 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() { return jresult; } - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) { Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ; @@ -68596,6 +68592,144 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, i } +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = 0 ; + Dali::Toolkit::LayoutItem result; + + 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::DevelControl::GetLayout(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::Control arg1 ; + Dali::Toolkit::Control *argp1 ; + Dali::Toolkit::LayoutItem result; + + argp1 = (Dali::Toolkit::Control *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = Dali::Toolkit::DevelControl::GetLayout(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = 0 ; + Dali::Toolkit::LayoutItem arg2 ; + Dali::Toolkit::LayoutItem *argp2 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0); + return ; + } + argp2 = (Dali::Toolkit::LayoutItem *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali::Toolkit::DevelControl::SetLayout(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) { + Dali::Toolkit::Control arg1 ; + Dali::Toolkit::LayoutItem arg2 ; + Dali::Toolkit::Control *argp1 ; + Dali::Toolkit::LayoutItem *argp2 ; + + argp1 = (Dali::Toolkit::Control *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0); + return ; + } + arg1 = *argp1; + argp2 = (Dali::Toolkit::LayoutItem *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali::Toolkit::DevelControl::SetLayout(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) { void * jresult ; Dali::Toolkit::Control *arg1 = 0 ; diff --git a/dali-csharp-binder/src/dali_wrap.h b/dali-csharp-binder/src/dali_wrap.h index 78f2878..1fe0a90 100755 --- a/dali-csharp-binder/src/dali_wrap.h +++ b/dali-csharp-binder/src/dali_wrap.h @@ -280,5 +280,4 @@ private: void swig_init_callbacks(); }; - #endif diff --git a/dali-csharp-binder/src/layout-group-wrapper-impl.cpp b/dali-csharp-binder/src/layout-group-wrapper-impl.cpp new file mode 100755 index 0000000..1784345 --- /dev/null +++ b/dali-csharp-binder/src/layout-group-wrapper-impl.cpp @@ -0,0 +1,1282 @@ +/* + * 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. + * + */ + +// CLASS HEADER +#include "layout-group-wrapper-impl.h" + +// INTERNAL INCLUDES + +#ifdef __cplusplus +extern "C" { +#endif + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +using namespace Dali::Toolkit; + +SwigDirector_LayoutGroupWrapperImpl::SwigDirector_LayoutGroupWrapperImpl() : Dali::Toolkit::Internal::LayoutGroup() +{ + swig_init_callbacks(); +} + +SwigDirector_LayoutGroupWrapperImpl::~SwigDirector_LayoutGroupWrapperImpl() +{ + +} + +Dali::Toolkit::Internal::LayoutParent *SwigDirector_LayoutGroupWrapperImpl::GetParent() +{ + Dali::Toolkit::Internal::LayoutParent *c_result = 0 ; + void * jresult = 0 ; + + if (!swig_callbackGetParent) + { + return Dali::Toolkit::Internal::LayoutItem::GetParent(); + } + else + { + jresult = (void *) swig_callbackGetParent(); + c_result = (Dali::Toolkit::Internal::LayoutParent *)jresult; + } + return c_result; +} + +void SwigDirector_LayoutGroupWrapperImpl::OnMeasure(Dali::Toolkit::MeasureSpec widthMeasureSpec, Dali::Toolkit::MeasureSpec heightMeasureSpec) +{ + void * jwidthMeasureSpec ; + void * jheightMeasureSpec ; + + if (!swig_callbackOnMeasure) + { + Dali::Toolkit::Internal::LayoutItem::OnMeasure(widthMeasureSpec,heightMeasureSpec); + return; + } + else + { + jwidthMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)widthMeasureSpec); + jheightMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)heightMeasureSpec); + swig_callbackOnMeasure(jwidthMeasureSpec, jheightMeasureSpec); + } +} + +void SwigDirector_LayoutGroupWrapperImpl::OnLayout(bool changed, Dali::Toolkit::LayoutLength left, Dali::Toolkit::LayoutLength top, Dali::Toolkit::LayoutLength right, Dali::Toolkit::LayoutLength bottom) +{ + unsigned int jchanged ; + void * jleft ; + void * jtop ; + void * jright ; + void * jbottom ; + + if (!swig_callbackOnLayout) + { + Dali::Toolkit::Internal::LayoutItem::OnLayout(changed,left,top,right,bottom); + return; + } + else + { + jchanged = changed; + jleft = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)left); + jtop = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)top); + jright = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)right); + jbottom = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)bottom); + swig_callbackOnLayout(jchanged, jleft, jtop, jright, jbottom); + } +} + +void SwigDirector_LayoutGroupWrapperImpl::OnSizeChanged(LayoutSize newSize, LayoutSize oldSize) +{ + void * jnewSize ; + void * joldSize ; + + if (!swig_callbackOnSizeChanged) + { + Dali::Toolkit::Internal::LayoutItem::OnSizeChanged(newSize,oldSize); + return; + } + else + { + jnewSize = (void *)new LayoutSize((const LayoutSize &)newSize); + joldSize = (void *)new LayoutSize((const LayoutSize &)oldSize); + swig_callbackOnSizeChanged(jnewSize, joldSize); + } +} + +void SwigDirector_LayoutGroupWrapperImpl::OnChildAdd(Dali::Toolkit::Internal::LayoutItem &child) +{ + void * jchild = 0 ; + + if (!swig_callbackOnChildAdd) + { + Dali::Toolkit::Internal::LayoutGroup::OnChildAdd(child); + return; + } + else + { + jchild = (Dali::Toolkit::Internal::LayoutItem *) &child; + swig_callbackOnChildAdd(jchild); + } +} + +void SwigDirector_LayoutGroupWrapperImpl::OnChildRemove(Dali::Toolkit::Internal::LayoutItem &child) +{ + void * jchild = 0 ; + + if (!swig_callbackOnChildRemove) + { + Dali::Toolkit::Internal::LayoutGroup::OnChildRemove(child); + return; + } + else + { + jchild = (Dali::Toolkit::Internal::LayoutItem *) &child; + swig_callbackOnChildRemove(jchild); + } +} + +void SwigDirector_LayoutGroupWrapperImpl::DoInitialize() +{ + if (!swig_callbackDoInitialize) + { + Dali::Toolkit::Internal::LayoutGroup::DoInitialize(); + return; + } + else + { + swig_callbackDoInitialize(); + } +} + +void SwigDirector_LayoutGroupWrapperImpl::DoRegisterChildProperties(std::string const &containerType) +{ + char * jcontainerType = 0 ; + + if (!swig_callbackDoRegisterChildProperties) + { + Dali::Toolkit::Internal::LayoutGroup::DoRegisterChildProperties(containerType); + return; + } + else + { + jcontainerType = SWIG_csharp_string_callback((&containerType)->c_str()); + swig_callbackDoRegisterChildProperties(jcontainerType); + } +} + +void SwigDirector_LayoutGroupWrapperImpl::GenerateDefaultChildPropertyValues(Dali::Handle child) +{ + void * jchild ; + + if (!swig_callbackGenerateDefaultChildPropertyValues) + { + Dali::Toolkit::Internal::LayoutGroup::GenerateDefaultChildPropertyValues(child); + return; + } + else + { + jchild = (void *)new Dali::Handle((const Dali::Handle &)child); + swig_callbackGenerateDefaultChildPropertyValues(jchild); + } +} + +void SwigDirector_LayoutGroupWrapperImpl::MeasureChildren(Dali::Toolkit::MeasureSpec widthMeasureSpec, Dali::Toolkit::MeasureSpec heightMeasureSpec) +{ + void * jwidthMeasureSpec ; + void * jheightMeasureSpec ; + + if (!swig_callbackMeasureChildren) + { + Dali::Toolkit::Internal::LayoutGroup::MeasureChildren(widthMeasureSpec,heightMeasureSpec); + return; + } + else + { + jwidthMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)widthMeasureSpec); + jheightMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)heightMeasureSpec); + swig_callbackMeasureChildren(jwidthMeasureSpec, jheightMeasureSpec); + } +} + +void SwigDirector_LayoutGroupWrapperImpl::MeasureChild(Dali::Toolkit::Internal::LayoutItemPtr child, Dali::Toolkit::MeasureSpec parentWidthMeasureSpec, Dali::Toolkit::MeasureSpec parentHeightMeasureSpec) +{ + void * jchild ; + void * jparentWidthMeasureSpec ; + void * jparentHeightMeasureSpec ; + + if (!swig_callbackMeasureChild) + { + Dali::Toolkit::Internal::LayoutGroup::MeasureChild(child,parentWidthMeasureSpec,parentHeightMeasureSpec); + return; + } + else + { + jchild = (void *)new Dali::Toolkit::Internal::LayoutItemPtr((const Dali::Toolkit::Internal::LayoutItemPtr &)child); + jparentWidthMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)parentWidthMeasureSpec); + jparentHeightMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)parentHeightMeasureSpec); + swig_callbackMeasureChild(jchild, jparentWidthMeasureSpec, jparentHeightMeasureSpec); + } +} + +void SwigDirector_LayoutGroupWrapperImpl::MeasureChildWithMargins(Dali::Toolkit::Internal::LayoutItemPtr child, Dali::Toolkit::MeasureSpec parentWidthMeasureSpec, Dali::Toolkit::LayoutLength widthUsed, Dali::Toolkit::MeasureSpec parentHeightMeasureSpec, Dali::Toolkit::LayoutLength heightUsed) +{ + void * jchild ; + void * jparentWidthMeasureSpec ; + void * jwidthUsed ; + void * jparentHeightMeasureSpec ; + void * jheightUsed ; + + if (!swig_callbackMeasureChildWithMargins) + { + Dali::Toolkit::Internal::LayoutGroup::MeasureChildWithMargins(child,parentWidthMeasureSpec,widthUsed,parentHeightMeasureSpec,heightUsed); + return; + } + else + { + jchild = (void *)new Dali::Toolkit::Internal::LayoutItemPtr((const Dali::Toolkit::Internal::LayoutItemPtr &)child); + jparentWidthMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)parentWidthMeasureSpec); + jwidthUsed = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)widthUsed); + jparentHeightMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)parentHeightMeasureSpec); + jheightUsed = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)heightUsed); + swig_callbackMeasureChildWithMargins(jchild, jparentWidthMeasureSpec, jwidthUsed, jparentHeightMeasureSpec, jheightUsed); + } +} + +void SwigDirector_LayoutGroupWrapperImpl::swig_connect_director(SWIG_Callback0_t callbackGetParent, SWIG_Callback3_t callbackOnMeasure, SWIG_Callback4_t callbackOnLayout, SWIG_Callback5_t callbackOnSizeChanged, SWIG_Callback6_t callbackOnInitialize, SWIG_Callback7_t callbackOnChildAdd, SWIG_Callback8_t callbackOnChildRemove, SWIG_Callback9_t callbackDoInitialize, SWIG_Callback10_t callbackDoRegisterChildProperties, SWIG_Callback11_t callbackGenerateDefaultChildPropertyValues, SWIG_Callback12_t callbackMeasureChildren, SWIG_Callback13_t callbackMeasureChild, SWIG_Callback14_t callbackMeasureChildWithMargins) +{ + swig_callbackGetParent = callbackGetParent; + swig_callbackOnMeasure = callbackOnMeasure; + swig_callbackOnLayout = callbackOnLayout; + swig_callbackOnSizeChanged = callbackOnSizeChanged; + swig_callbackOnInitialize = callbackOnInitialize; + swig_callbackOnChildAdd = callbackOnChildAdd; + swig_callbackOnChildRemove = callbackOnChildRemove; + swig_callbackDoInitialize = callbackDoInitialize; + swig_callbackDoRegisterChildProperties = callbackDoRegisterChildProperties; + swig_callbackGenerateDefaultChildPropertyValues = callbackGenerateDefaultChildPropertyValues; + swig_callbackMeasureChildren = callbackMeasureChildren; + swig_callbackMeasureChild = callbackMeasureChild; + swig_callbackMeasureChildWithMargins = callbackMeasureChildWithMargins; +} + +void SwigDirector_LayoutGroupWrapperImpl::swig_init_callbacks() +{ + swig_callbackGetParent = 0; + swig_callbackOnMeasure = 0; + swig_callbackOnLayout = 0; + swig_callbackOnSizeChanged = 0; + swig_callbackOnInitialize = 0; + swig_callbackOnChildAdd = 0; + swig_callbackOnChildRemove = 0; + swig_callbackDoInitialize = 0; + swig_callbackDoRegisterChildProperties = 0; + swig_callbackGenerateDefaultChildPropertyValues = 0; + swig_callbackMeasureChildren = 0; + swig_callbackMeasureChild = 0; + swig_callbackMeasureChildWithMargins = 0; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_Add(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::Internal::LayoutItem *arg2 = 0 ; + Dali::Toolkit::LayoutGroup::LayoutId result; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::Internal::LayoutItem *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::LayoutItem & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutGroup::LayoutId)(arg1)->Add(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_Remove__SWIG_0(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::LayoutGroup::LayoutId arg2 ; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::LayoutGroup::LayoutId)jarg2; + { + try { + (arg1)->Remove(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_Remove__SWIG_1(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::Internal::LayoutItem *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::Internal::LayoutItem *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::LayoutItem & type is null", 0); + return ; + } + { + try { + (arg1)->Remove(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_RemoveAll(void * jarg1) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + { + try { + (arg1)->RemoveAll(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_GetChildCount(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + { + try { + result = (unsigned int)((Dali::Toolkit::Internal::LayoutGroup const *)arg1)->GetChildCount(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_GetChildAt(void * jarg1, unsigned int jarg2) { + void * jresult ; + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + unsigned int arg2 ; + Dali::Toolkit::Internal::LayoutItemPtr result; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = ((Dali::Toolkit::Internal::LayoutGroup const *)arg1)->GetChildAt(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::Internal::LayoutItemPtr((const Dali::Toolkit::Internal::LayoutItemPtr &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_GetChildId(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::Internal::LayoutItem *arg2 = 0 ; + Dali::Toolkit::LayoutGroup::LayoutId result; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::Internal::LayoutItem *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::LayoutItem & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutGroup::LayoutId)((Dali::Toolkit::Internal::LayoutGroup const *)arg1)->GetChildId(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_GetChild(void * jarg1, unsigned int jarg2) { + void * jresult ; + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::LayoutGroup::LayoutId arg2 ; + Dali::Toolkit::Internal::LayoutItemPtr result; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::LayoutGroup::LayoutId)jarg2; + { + try { + result = ((Dali::Toolkit::Internal::LayoutGroup const *)arg1)->GetChild(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::Internal::LayoutItemPtr((const Dali::Toolkit::Internal::LayoutItemPtr &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_OnChildAdd(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::Internal::LayoutItem *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::Internal::LayoutItem *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::LayoutItem & type is null", 0); + return ; + } + { + try { + (arg1)->OnChildAdd(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_OnChildAddSwigExplicitLayoutGroupWrapperImpl(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::Internal::LayoutItem *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::Internal::LayoutItem *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::LayoutItem & type is null", 0); + return ; + } + { + try { + (arg1)->Dali::Toolkit::Internal::LayoutGroup::OnChildAdd(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_OnChildRemove(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::Internal::LayoutItem *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::Internal::LayoutItem *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::LayoutItem & type is null", 0); + return ; + } + { + try { + (arg1)->OnChildRemove(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_OnChildRemoveSwigExplicitLayoutGroupWrapperImpl(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::Internal::LayoutItem *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::Internal::LayoutItem *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::LayoutItem & type is null", 0); + return ; + } + { + try { + (arg1)->Dali::Toolkit::Internal::LayoutGroup::OnChildRemove(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_GetChildMeasureSpec(void * jarg1, void * jarg2, void * jarg3) { + void * jresult ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg1 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ; + Dali::Toolkit::MeasureSpec *argp1 ; + Dali::Toolkit::LayoutLength *argp2 ; + Dali::Toolkit::LayoutLength *argp3 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > result; + + argp1 = (Dali::Toolkit::MeasureSpec *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return 0; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::LayoutLength *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return 0; + } + arg3 = *argp3; + { + try { + result = Dali::Toolkit::Internal::LayoutGroup::GetChildMeasureSpec(arg1,arg2,arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_DoInitialize(void * jarg1) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + darg = dynamic_cast(arg1); + { + try { + (darg)->DoInitialize(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_DoInitializeSwigExplicitLayoutGroupWrapperImpl(void * jarg1) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + darg = dynamic_cast(arg1); + { + try { + (darg)->DoInitializeSwigPublic(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_DoRegisterChildProperties(void * jarg1, char * jarg2) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + std::string *arg2 = 0 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + darg = dynamic_cast(arg1); + { + try { + (darg)->DoRegisterChildProperties((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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_DoRegisterChildPropertiesSwigExplicitLayoutGroupWrapperImpl(void * jarg1, char * jarg2) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + std::string *arg2 = 0 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + darg = dynamic_cast(arg1); + { + try { + (darg)->DoRegisterChildPropertiesSwigPublic((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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_GenerateDefaultChildPropertyValues(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Handle arg2 ; + Dali::Handle *argp2 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + argp2 = (Dali::Handle *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0); + return ; + } + arg2 = *argp2; + darg = dynamic_cast(arg1); + { + try { + (darg)->GenerateDefaultChildPropertyValues(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_GenerateDefaultChildPropertyValuesSwigExplicitLayoutGroupWrapperImpl(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Handle arg2 ; + Dali::Handle *argp2 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + argp2 = (Dali::Handle *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0); + return ; + } + arg2 = *argp2; + darg = dynamic_cast(arg1); + { + try { + (darg)->GenerateDefaultChildPropertyValuesSwigPublic(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_MeasureChildren(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ; + Dali::Toolkit::MeasureSpec *argp2 ; + Dali::Toolkit::MeasureSpec *argp3 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + argp2 = (Dali::Toolkit::MeasureSpec *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasureSpec *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg3 = *argp3; + darg = dynamic_cast(arg1); + { + try { + (darg)->MeasureChildren(arg2,arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_MeasureChildrenSwigExplicitLayoutGroupWrapperImpl(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ; + Dali::Toolkit::MeasureSpec *argp2 ; + Dali::Toolkit::MeasureSpec *argp3 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + argp2 = (Dali::Toolkit::MeasureSpec *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasureSpec *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg3 = *argp3; + darg = dynamic_cast(arg1); + { + try { + (darg)->MeasureChildrenSwigPublic(arg2,arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_MeasureChild(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::Internal::LayoutItemPtr arg2 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg4 ; + Dali::Toolkit::Internal::LayoutItemPtr *argp2 ; + Dali::Toolkit::MeasureSpec *argp3 ; + Dali::Toolkit::MeasureSpec *argp4 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + argp2 = (Dali::Toolkit::Internal::LayoutItemPtr *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Internal::LayoutItemPtr", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasureSpec *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::Toolkit::MeasureSpec *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg4 = *argp4; + darg = dynamic_cast(arg1); + { + try { + (darg)->MeasureChild(arg2,arg3,arg4); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_MeasureChildSwigExplicitLayoutGroupWrapperImpl(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::Internal::LayoutItemPtr arg2 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg4 ; + Dali::Toolkit::Internal::LayoutItemPtr *argp2 ; + Dali::Toolkit::MeasureSpec *argp3 ; + Dali::Toolkit::MeasureSpec *argp4 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + argp2 = (Dali::Toolkit::Internal::LayoutItemPtr *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Internal::LayoutItemPtr", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasureSpec *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::Toolkit::MeasureSpec *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg4 = *argp4; + darg = dynamic_cast(arg1); + { + try { + (darg)->MeasureChildSwigPublic(arg2,arg3,arg4); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_MeasureChildWithMargins(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::Internal::LayoutItemPtr arg2 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg5 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg6 ; + Dali::Toolkit::Internal::LayoutItemPtr *argp2 ; + Dali::Toolkit::MeasureSpec *argp3 ; + Dali::Toolkit::LayoutLength *argp4 ; + Dali::Toolkit::MeasureSpec *argp5 ; + Dali::Toolkit::LayoutLength *argp6 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + argp2 = (Dali::Toolkit::Internal::LayoutItemPtr *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Internal::LayoutItemPtr", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasureSpec *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::Toolkit::LayoutLength *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg4 = *argp4; + argp5 = (Dali::Toolkit::MeasureSpec *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg5 = *argp5; + argp6 = (Dali::Toolkit::LayoutLength *)jarg6; + if (!argp6) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg6 = *argp6; + darg = dynamic_cast(arg1); + { + try { + (darg)->MeasureChildWithMargins(arg2,arg3,arg4,arg5,arg6); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_MeasureChildWithMarginsSwigExplicitLayoutGroupWrapperImpl(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) { + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::Internal::LayoutItemPtr arg2 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg5 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg6 ; + Dali::Toolkit::Internal::LayoutItemPtr *argp2 ; + Dali::Toolkit::MeasureSpec *argp3 ; + Dali::Toolkit::LayoutLength *argp4 ; + Dali::Toolkit::MeasureSpec *argp5 ; + Dali::Toolkit::LayoutLength *argp6 ; + SwigDirector_LayoutGroupWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + argp2 = (Dali::Toolkit::Internal::LayoutItemPtr *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Internal::LayoutItemPtr", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasureSpec *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::Toolkit::LayoutLength *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg4 = *argp4; + argp5 = (Dali::Toolkit::MeasureSpec *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg5 = *argp5; + argp6 = (Dali::Toolkit::LayoutLength *)jarg6; + if (!argp6) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg6 = *argp6; + darg = dynamic_cast(arg1); + { + try { + (darg)->MeasureChildWithMarginsSwigPublic(arg2,arg3,arg4,arg5,arg6); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_director_connect(void *objarg, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback0_t callback0, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback3_t callback3, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback4_t callback4, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback5_t callback5, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback6_t callback6, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback7_t callback7, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback8_t callback8, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback9_t callback9, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback10_t callback10, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback11_t callback11, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback12_t callback12, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback13_t callback13, SwigDirector_LayoutGroupWrapperImpl::SWIG_Callback14_t callback14) { + Dali::Toolkit::Internal::LayoutGroup *obj = (Dali::Toolkit::Internal::LayoutGroup *)objarg; + SwigDirector_LayoutGroupWrapperImpl *director = dynamic_cast(obj); + if (director) { + director->swig_connect_director(callback0, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14); + } +} + + +/*SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Toolkit::LayoutGroup *arg1 = 0 ; + Dali::Toolkit::Internal::LayoutGroup *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutGroup *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutGroup & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Internal::LayoutGroup *) &Dali::Toolkit::GetImplementation(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +}*/ + +SWIGEXPORT Dali::Toolkit::Internal::LayoutItem * SWIGSTDCALL CSharp_Dali_LayoutGroupWrapperImpl_SWIGUpcast(Dali::Toolkit::Internal::LayoutGroup *jarg1) { + return (Dali::Toolkit::Internal::LayoutItem *)jarg1; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutGroupWrapperImpl() +{ + void * jresult ; + Dali::Toolkit::Internal::LayoutGroup *result = 0 ; + + try + { + result = (Dali::Toolkit::Internal::LayoutGroup *) new SwigDirector_LayoutGroupWrapperImpl(); + } + 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; +} + +#ifdef __cplusplus +} +#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/layout-group-wrapper-impl.h b/dali-csharp-binder/src/layout-group-wrapper-impl.h new file mode 100644 index 0000000..1fa858e --- /dev/null +++ b/dali-csharp-binder/src/layout-group-wrapper-impl.h @@ -0,0 +1,110 @@ +#ifndef CSHARP_LAYOUT_GROUP_WRAPPER_IMPL_H +#define CSHARP_LAYOUT_GROUP_WRAPPER_IMPL_H + +/* + * 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. + * + */ + +#include +#include "common.h" + +class SwigDirector_LayoutGroupWrapperImpl : public Dali::Toolkit::Internal::LayoutGroup +{ +public: + SwigDirector_LayoutGroupWrapperImpl(); + virtual ~SwigDirector_LayoutGroupWrapperImpl(); + virtual Dali::Toolkit::Internal::LayoutParent *GetParent(); + virtual void OnMeasure(Dali::Toolkit::MeasureSpec widthMeasureSpec, Dali::Toolkit::MeasureSpec heightMeasureSpec); + virtual void OnMeasureSwigPublic(Dali::Toolkit::MeasureSpec widthMeasureSpec, Dali::Toolkit::MeasureSpec heightMeasureSpec) + { + Dali::Toolkit::Internal::LayoutItem::OnMeasure(widthMeasureSpec,heightMeasureSpec); + } + virtual void OnLayout(bool changed, Dali::Toolkit::LayoutLength left, Dali::Toolkit::LayoutLength top, Dali::Toolkit::LayoutLength right, Dali::Toolkit::LayoutLength bottom); + virtual void OnLayoutSwigPublic(bool changed, Dali::Toolkit::LayoutLength left, Dali::Toolkit::LayoutLength top, Dali::Toolkit::LayoutLength right, Dali::Toolkit::LayoutLength bottom) + { + Dali::Toolkit::Internal::LayoutItem::OnLayout(changed,left,top,right,bottom); + } + virtual void OnSizeChanged(Dali::Toolkit::LayoutSize newSize, Dali::Toolkit::LayoutSize oldSize); + virtual void OnSizeChangedSwigPublic(Dali::Toolkit::LayoutSize newSize, Dali::Toolkit::LayoutSize oldSize) + { + Dali::Toolkit::Internal::LayoutItem::OnSizeChanged(newSize,oldSize); + } + virtual void OnChildAdd(Dali::Toolkit::Internal::LayoutItem &child); + virtual void OnChildRemove(Dali::Toolkit::Internal::LayoutItem &child); + virtual void DoInitialize(); + virtual void DoInitializeSwigPublic() + { + Dali::Toolkit::Internal::LayoutGroup::DoInitialize(); + } + virtual void DoRegisterChildProperties(std::string const &containerType); + virtual void DoRegisterChildPropertiesSwigPublic(std::string const &containerType) + { + Dali::Toolkit::Internal::LayoutGroup::DoRegisterChildProperties(containerType); + } + virtual void GenerateDefaultChildPropertyValues(Dali::Handle child); + virtual void GenerateDefaultChildPropertyValuesSwigPublic(Dali::Handle child) + { + Dali::Toolkit::Internal::LayoutGroup::GenerateDefaultChildPropertyValues(child); + } + virtual void MeasureChildren(Dali::Toolkit::MeasureSpec widthMeasureSpec, Dali::Toolkit::MeasureSpec heightMeasureSpec); + virtual void MeasureChildrenSwigPublic(Dali::Toolkit::MeasureSpec widthMeasureSpec, Dali::Toolkit::MeasureSpec heightMeasureSpec) + { + Dali::Toolkit::Internal::LayoutGroup::MeasureChildren(widthMeasureSpec,heightMeasureSpec); + } + virtual void MeasureChild(Dali::Toolkit::Internal::LayoutItemPtr child, Dali::Toolkit::MeasureSpec parentWidthMeasureSpec, Dali::Toolkit::MeasureSpec parentHeightMeasureSpec); + virtual void MeasureChildSwigPublic(Dali::Toolkit::Internal::LayoutItemPtr child, Dali::Toolkit::MeasureSpec parentWidthMeasureSpec, Dali::Toolkit::MeasureSpec parentHeightMeasureSpec) + { + Dali::Toolkit::Internal::LayoutGroup::MeasureChild(child,parentWidthMeasureSpec,parentHeightMeasureSpec); + } + virtual void MeasureChildWithMargins(Dali::Toolkit::Internal::LayoutItemPtr child, Dali::Toolkit::MeasureSpec parentWidthMeasureSpec, Dali::Toolkit::LayoutLength widthUsed, Dali::Toolkit::MeasureSpec parentHeightMeasureSpec, Dali::Toolkit::LayoutLength heightUsed); + virtual void MeasureChildWithMarginsSwigPublic(Dali::Toolkit::Internal::LayoutItemPtr child, Dali::Toolkit::MeasureSpec parentWidthMeasureSpec, Dali::Toolkit::LayoutLength widthUsed, Dali::Toolkit::MeasureSpec parentHeightMeasureSpec, Dali::Toolkit::LayoutLength heightUsed) + { + Dali::Toolkit::Internal::LayoutGroup::MeasureChildWithMargins(child,parentWidthMeasureSpec,widthUsed,parentHeightMeasureSpec,heightUsed); + } + + typedef void * (SWIGSTDCALL* SWIG_Callback0_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback3_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback4_t)(unsigned int, void *, void *, void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback5_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback6_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback7_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback8_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback9_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback10_t)(char *); + typedef void (SWIGSTDCALL* SWIG_Callback11_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback12_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback13_t)(void *, void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback14_t)(void *, void *, void *, void *, void *); + void swig_connect_director(SWIG_Callback0_t callbackGetParent, SWIG_Callback3_t callbackOnMeasure, SWIG_Callback4_t callbackOnLayout, SWIG_Callback5_t callbackOnSizeChanged, SWIG_Callback6_t callbackOnInitialize, SWIG_Callback7_t callbackOnChildAdd, SWIG_Callback8_t callbackOnChildRemove, SWIG_Callback9_t callbackDoInitialize, SWIG_Callback10_t callbackDoRegisterChildProperties, SWIG_Callback11_t callbackGenerateDefaultChildPropertyValues, SWIG_Callback12_t callbackMeasureChildren, SWIG_Callback13_t callbackMeasureChild, SWIG_Callback14_t callbackMeasureChildWithMargins); + +private: + SWIG_Callback0_t swig_callbackGetParent; + SWIG_Callback3_t swig_callbackOnMeasure; + SWIG_Callback4_t swig_callbackOnLayout; + SWIG_Callback5_t swig_callbackOnSizeChanged; + SWIG_Callback6_t swig_callbackOnInitialize; + SWIG_Callback7_t swig_callbackOnChildAdd; + SWIG_Callback8_t swig_callbackOnChildRemove; + SWIG_Callback9_t swig_callbackDoInitialize; + SWIG_Callback10_t swig_callbackDoRegisterChildProperties; + SWIG_Callback11_t swig_callbackGenerateDefaultChildPropertyValues; + SWIG_Callback12_t swig_callbackMeasureChildren; + SWIG_Callback13_t swig_callbackMeasureChild; + SWIG_Callback14_t swig_callbackMeasureChildWithMargins; + void swig_init_callbacks(); +}; + +#endif /* CSHARP_LAYOUT_GROUP_WRAPPER_IMPL_H */ diff --git a/dali-csharp-binder/src/layout-group-wrapper.cpp b/dali-csharp-binder/src/layout-group-wrapper.cpp new file mode 100755 index 0000000..9edc53e --- /dev/null +++ b/dali-csharp-binder/src/layout-group-wrapper.cpp @@ -0,0 +1,457 @@ +/* + * 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. + * + */ + +#include "common.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutGroupWrapper_UNKNOWN_ID_get() { + unsigned int jresult ; + unsigned int result; + + result = (unsigned int)Dali::Toolkit::LayoutGroup::UNKNOWN_ID; + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutGroupWrapper_ChildProperty_MARGIN_SPECIFICATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::LayoutGroup::ChildProperty::MARGIN_SPECIFICATION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutGroupWrapper_ChildProperty() { + void * jresult ; + Dali::Toolkit::LayoutGroup::ChildProperty *result = 0 ; + + { + try { + result = (Dali::Toolkit::LayoutGroup::ChildProperty *)new Dali::Toolkit::LayoutGroup::ChildProperty(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LayoutGroupWrapper_ChildProperty(void * jarg1) { + Dali::Toolkit::LayoutGroup::ChildProperty *arg1 = (Dali::Toolkit::LayoutGroup::ChildProperty *) 0 ; + + arg1 = (Dali::Toolkit::LayoutGroup::ChildProperty *)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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutGroupWrapper__SWIG_0() { + void * jresult ; + Dali::Toolkit::LayoutGroup *result = 0 ; + + { + try { + result = (Dali::Toolkit::LayoutGroup *)new Dali::Toolkit::LayoutGroup(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LayoutGroupWrapper(void * jarg1) { + Dali::Toolkit::LayoutGroup *arg1 = (Dali::Toolkit::LayoutGroup *) 0 ; + + arg1 = (Dali::Toolkit::LayoutGroup *)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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutGroupWrapper__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::LayoutGroup *arg1 = 0 ; + Dali::Toolkit::LayoutGroup *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutGroup *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutGroup const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutGroup *)new Dali::Toolkit::LayoutGroup((Dali::Toolkit::LayoutGroup 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutGroupWrapper_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::LayoutGroup *arg1 = (Dali::Toolkit::LayoutGroup *) 0 ; + Dali::Toolkit::LayoutGroup *arg2 = 0 ; + Dali::Toolkit::LayoutGroup *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::LayoutGroup *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutGroup const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutGroup *) &(arg1)->operator =((Dali::Toolkit::LayoutGroup 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutGroupWrapper_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::LayoutGroup 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::LayoutGroup::DownCast(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutGroup((const Dali::Toolkit::LayoutGroup &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutGroupWrapper_Add(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::LayoutGroup *arg1 = (Dali::Toolkit::LayoutGroup *) 0 ; + Dali::Toolkit::LayoutItem *arg2 = 0 ; + Dali::Toolkit::LayoutGroup::LayoutId result; + + arg1 = (Dali::Toolkit::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::LayoutItem *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutItem & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutGroup::LayoutId)(arg1)->Add(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapper_Remove__SWIG_0(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::LayoutGroup *arg1 = (Dali::Toolkit::LayoutGroup *) 0 ; + Dali::Toolkit::LayoutGroup::LayoutId arg2 ; + + arg1 = (Dali::Toolkit::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::LayoutGroup::LayoutId)jarg2; + { + try { + (arg1)->Remove(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutGroupWrapper_Remove__SWIG_1(void * jarg1, void * jarg2) { + Dali::Toolkit::LayoutGroup *arg1 = (Dali::Toolkit::LayoutGroup *) 0 ; + Dali::Toolkit::LayoutItem *arg2 = 0 ; + + arg1 = (Dali::Toolkit::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::LayoutItem *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutItem & type is null", 0); + return ; + } + { + try { + (arg1)->Remove(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutGroupWrapper_GetChildAt(void * jarg1, unsigned int jarg2) { + void * jresult ; + Dali::Toolkit::LayoutGroup *arg1 = (Dali::Toolkit::LayoutGroup *) 0 ; + unsigned int arg2 ; + Dali::Toolkit::LayoutItem result; + + arg1 = (Dali::Toolkit::LayoutGroup *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = ((Dali::Toolkit::LayoutGroup const *)arg1)->GetChildAt(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutGroupWrapper_GetChildCount(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::LayoutGroup *arg1 = (Dali::Toolkit::LayoutGroup *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::LayoutGroup *)jarg1; + { + try { + result = (unsigned int)((Dali::Toolkit::LayoutGroup const *)arg1)->GetChildCount(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutGroupWrapper_GetChild(void * jarg1, unsigned int jarg2) { + void * jresult ; + Dali::Toolkit::LayoutGroup *arg1 = (Dali::Toolkit::LayoutGroup *) 0 ; + Dali::Toolkit::LayoutGroup::LayoutId arg2 ; + Dali::Toolkit::LayoutItem result; + + arg1 = (Dali::Toolkit::LayoutGroup *)jarg1; + arg2 = (Dali::Toolkit::LayoutGroup::LayoutId)jarg2; + { + try { + result = ((Dali::Toolkit::LayoutGroup const *)arg1)->GetChild(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutGroupWrapper__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutGroup *arg1 = (Dali::Toolkit::Internal::LayoutGroup *) 0 ; + Dali::Toolkit::LayoutGroup *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutGroup *)jarg1; + { + try { + result = (Dali::Toolkit::LayoutGroup *)new Dali::Toolkit::LayoutGroup(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT Dali::Toolkit::LayoutItem * SWIGSTDCALL CSharp_Dali_LayoutGroupWrapper_SWIGUpcast(Dali::Toolkit::LayoutGroup *jarg1) { + return (Dali::Toolkit::LayoutItem *)jarg1; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/src/layout-item-ptr.cpp b/dali-csharp-binder/src/layout-item-ptr.cpp new file mode 100755 index 0000000..e4d6e98 --- /dev/null +++ b/dali-csharp-binder/src/layout-item-ptr.cpp @@ -0,0 +1,1311 @@ +/* + * 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. + * + */ + +#include "common.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemPtr__SWIG_0() { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *result = 0 ; + + { + try { + result = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)new Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem >(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemPtr__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)new Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem >(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemPtr__SWIG_2(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = 0 ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)new Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem >((Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LayoutItemPtr(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Get(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Toolkit::Internal::LayoutItem *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (Dali::Toolkit::Internal::LayoutItem *)((Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const *)arg1)->Get(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr___deref__(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Toolkit::Internal::LayoutItem *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (Dali::Toolkit::Internal::LayoutItem *)((Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const *)arg1)->operator ->(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr___ref__(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Toolkit::Internal::LayoutItem *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (Dali::Toolkit::Internal::LayoutItem *) &((Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const *)arg1)->operator *(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Assign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg2 = 0 ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Assign__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Toolkit::Internal::LayoutItem *arg2 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + arg2 = (Dali::Toolkit::Internal::LayoutItem *)jarg2; + { + try { + result = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) &(arg1)->operator =(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Reset__SWIG_0(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + (arg1)->Reset(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Reset__SWIG_1(void * jarg1, void * jarg2) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Toolkit::Internal::LayoutItem *arg2 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + arg2 = (Dali::Toolkit::Internal::LayoutItem *)jarg2; + { + try { + (arg1)->Reset(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Detach(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Toolkit::Internal::LayoutItem *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (Dali::Toolkit::Internal::LayoutItem *)(arg1)->Detach(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_New(void * jarg1, void * jarg2) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Handle *arg2 = 0 ; + Dali::Toolkit::Internal::LayoutItemPtr result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + arg2 = (Dali::Handle *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return 0; + } + { + try { + result = (*arg1)->New(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::Internal::LayoutItemPtr((const Dali::Toolkit::Internal::LayoutItemPtr &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Initialize(void * jarg1, void * jarg2, char * jarg3) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Handle *arg2 = 0 ; + std::string *arg3 = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + arg2 = (Dali::Handle *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return ; + } + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + { + try { + (*arg1)->Initialize(*arg2,(std::string const &)*arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Unparent(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + (*arg1)->Unparent(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_SetAnimateLayout(void * jarg1, unsigned int jarg2) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + bool arg2 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (*arg1)->SetAnimateLayout(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_IsLayoutAnimated(void * jarg1) { + unsigned int jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + bool result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (bool)(*arg1)->IsLayoutAnimated(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_RegisterChildProperties(void * jarg1, char * jarg2) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + (*arg1)->RegisterChildProperties((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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Measure(void * jarg1, void * jarg2, void * jarg3) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ; + Dali::Toolkit::MeasureSpec *argp2 ; + Dali::Toolkit::MeasureSpec *argp3 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + argp2 = (Dali::Toolkit::MeasureSpec *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasureSpec *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg3 = *argp3; + { + try { + (*arg1)->Measure(arg2,arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Layout(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ; + Dali::Toolkit::LayoutLength *argp2 ; + Dali::Toolkit::LayoutLength *argp3 ; + Dali::Toolkit::LayoutLength *argp4 ; + Dali::Toolkit::LayoutLength *argp5 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + argp2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::LayoutLength *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::Toolkit::LayoutLength *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg4 = *argp4; + argp5 = (Dali::Toolkit::LayoutLength *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg5 = *argp5; + { + try { + (*arg1)->Layout(arg2,arg3,arg4,arg5); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetDefaultSize(void * jarg1, void * jarg2, void * jarg3) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ; + Dali::Toolkit::LayoutLength *argp2 ; + Dali::Toolkit::MeasureSpec *argp3 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + argp2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return 0; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasureSpec *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return 0; + } + arg3 = *argp3; + { + try { + result = (*arg1)->GetDefaultSize(arg2,arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetParent(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Toolkit::Internal::LayoutParent *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (Dali::Toolkit::Internal::LayoutParent *)(*arg1)->GetParent(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_RequestLayout(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + (*arg1)->RequestLayout(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_IsLayoutRequested(void * jarg1) { + unsigned int jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + bool result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (bool)(*arg1)->IsLayoutRequested(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMeasuredWidth(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (*arg1)->GetMeasuredWidth(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMeasuredHeight(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (*arg1)->GetMeasuredHeight(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMeasuredWidthAndState(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Toolkit::MeasuredSize result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (*arg1)->GetMeasuredWidthAndState(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::MeasuredSize((const Dali::Toolkit::MeasuredSize &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMeasuredHeightAndState(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Toolkit::MeasuredSize result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (*arg1)->GetMeasuredHeightAndState(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::MeasuredSize((const Dali::Toolkit::MeasuredSize &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetSuggestedMinimumWidth(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (*arg1)->GetSuggestedMinimumWidth(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetSuggestedMinimumHeight(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (*arg1)->GetSuggestedMinimumHeight(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_SetMinimumWidth(void * jarg1, void * jarg2) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ; + Dali::Toolkit::LayoutLength *argp2 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + argp2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg2 = *argp2; + { + try { + (*arg1)->SetMinimumWidth(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_SetMinimumHeight(void * jarg1, void * jarg2) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ; + Dali::Toolkit::LayoutLength *argp2 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + argp2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg2 = *argp2; + { + try { + (*arg1)->SetMinimumHeight(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMinimumWidth(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (*arg1)->GetMinimumWidth(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMinimumHeight(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (*arg1)->GetMinimumHeight(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetPadding(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::Extents result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (*arg1)->GetPadding(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Extents((const Dali::Extents &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_DoAction(void * jarg1, char * jarg2, void * jarg3) { + unsigned int jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Map *arg3 = 0 ; + bool result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)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); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetTypeName(void * jarg1) { + char * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + std::string *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (std::string *) &(*arg1)->GetTypeName(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetTypeInfo(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + Dali::TypeInfo *arg2 = 0 ; + bool result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + arg2 = (Dali::TypeInfo *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0); + return 0; + } + { + try { + result = (bool)(*arg1)->GetTypeInfo(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +/*SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) { + unsigned int jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ; + std::string *arg3 = 0 ; + FunctorDelegate *arg4 = (FunctorDelegate *) 0 ; + bool result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)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); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + + //argout typemap for const std::string& + + return jresult; +}*/ + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Reference(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + (*arg1)->Reference(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Unreference(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + (*arg1)->Unreference(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_ReferenceCount(void * jarg1) { + int jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ; + int result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1; + { + try { + result = (int)(*arg1)->ReferenceCount(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/src/layout-item-wrapper-impl.cpp b/dali-csharp-binder/src/layout-item-wrapper-impl.cpp new file mode 100755 index 0000000..024cd05 --- /dev/null +++ b/dali-csharp-binder/src/layout-item-wrapper-impl.cpp @@ -0,0 +1,1509 @@ +/* + * 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. + * + */ + +// CLASS HEADER +#include "layout-item-wrapper-impl.h" + +// INTERNAL INCLUDES + +#ifdef __cplusplus +extern "C" { +#endif + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +using namespace Dali::Toolkit; + +SwigDirector_LayoutItemWrapperImpl::SwigDirector_LayoutItemWrapperImpl() : Dali::Toolkit::Internal::LayoutItem() +{ + swig_init_callbacks(); +} + +SwigDirector_LayoutItemWrapperImpl::~SwigDirector_LayoutItemWrapperImpl() +{ + +} + +Dali::Toolkit::Internal::LayoutParent *SwigDirector_LayoutItemWrapperImpl::GetParent() +{ + Dali::Toolkit::Internal::LayoutParent *c_result = 0; + void * jresult = 0; + + if (!swig_callbackGetParent) + { + return Dali::Toolkit::Internal::LayoutItem::GetParent(); + } + else + { + jresult = (void *) swig_callbackGetParent(); + c_result = (Dali::Toolkit::Internal::LayoutParent *)jresult; + } + return c_result; +} + +void SwigDirector_LayoutItemWrapperImpl::OnUnparent() +{ + if (!swig_callbackOnUnparent) + { + Dali::Toolkit::Internal::LayoutItem::OnUnparent(); + return; + } + else + { + swig_callbackOnUnparent(); + } +} + +void SwigDirector_LayoutItemWrapperImpl::OnRegisterChildProperties(std::string const &containerType) +{ + char * jcontainerType = 0; + + if (!swig_callbackOnRegisterChildProperties) + { + Dali::Toolkit::Internal::LayoutItem::OnRegisterChildProperties(containerType); + return; + } + else + { + jcontainerType = SWIG_csharp_string_callback((&containerType)->c_str()); + swig_callbackOnRegisterChildProperties(jcontainerType); + } +} + +void SwigDirector_LayoutItemWrapperImpl::OnMeasure(Dali::Toolkit::MeasureSpec widthMeasureSpec, Dali::Toolkit::MeasureSpec heightMeasureSpec) +{ + void * jwidthMeasureSpec; + void * jheightMeasureSpec; + + if (!swig_callbackOnMeasure) + { + Dali::Toolkit::Internal::LayoutItem::OnMeasure(widthMeasureSpec,heightMeasureSpec); + return; + } + else + { + jwidthMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)widthMeasureSpec); + jheightMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)heightMeasureSpec); + swig_callbackOnMeasure(jwidthMeasureSpec, jheightMeasureSpec); + } +} + +void SwigDirector_LayoutItemWrapperImpl::OnLayout(bool changed, Dali::Toolkit::LayoutLength left, Dali::Toolkit::LayoutLength top, Dali::Toolkit::LayoutLength right, Dali::Toolkit::LayoutLength bottom) +{ + unsigned int jchanged; + void * jleft; + void * jtop; + void * jright; + void * jbottom; + + if (!swig_callbackOnLayout) + { + Dali::Toolkit::Internal::LayoutItem::OnLayout(changed,left,top,right,bottom); + return; + } + else + { + jchanged = changed; + jleft = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)left); + jtop = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)top); + jright = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)right); + jbottom = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)bottom); + swig_callbackOnLayout(jchanged, jleft, jtop, jright, jbottom); + } +} + +void SwigDirector_LayoutItemWrapperImpl::OnSizeChanged(Dali::Toolkit::LayoutSize newSize, Dali::Toolkit::LayoutSize oldSize) +{ + void * jnewSize; + void * joldSize; + + if (!swig_callbackOnSizeChanged) + { + Dali::Toolkit::Internal::LayoutItem::OnSizeChanged(newSize,oldSize); + return; + } + else + { + jnewSize = (void *)new Dali::Toolkit::LayoutSize((const Dali::Toolkit::LayoutSize &)newSize); + joldSize = (void *)new Dali::Toolkit::LayoutSize((const Dali::Toolkit::LayoutSize &)oldSize); + swig_callbackOnSizeChanged(jnewSize, joldSize); + } +} + +void SwigDirector_LayoutItemWrapperImpl::OnInitialize() +{ + if (!swig_callbackOnInitialize) + { + Dali::Toolkit::Internal::LayoutItem::OnInitialize(); + return; + } + else + { + swig_callbackOnInitialize(); + } +} + +void SwigDirector_LayoutItemWrapperImpl::SetMeasuredDimensions(Dali::Toolkit::MeasuredSize measuredWidth, Dali::Toolkit::MeasuredSize measuredHeight) +{ + Dali::Toolkit::Internal::LayoutItem::SetMeasuredDimensions(measuredWidth, measuredHeight); +} + +void SwigDirector_LayoutItemWrapperImpl::swig_connect_director(SWIG_Callback0_t callbackGetParent, SWIG_Callback1_t callbackOnUnparent, SWIG_Callback2_t callbackOnRegisterChildProperties, SWIG_Callback3_t callbackOnMeasure, SWIG_Callback4_t callbackOnLayout, SWIG_Callback5_t callbackOnSizeChanged, SWIG_Callback6_t callbackOnInitialize) +{ + swig_callbackGetParent = callbackGetParent; + swig_callbackOnUnparent = callbackOnUnparent; + swig_callbackOnRegisterChildProperties = callbackOnRegisterChildProperties; + swig_callbackOnMeasure = callbackOnMeasure; + swig_callbackOnLayout = callbackOnLayout; + swig_callbackOnSizeChanged = callbackOnSizeChanged; + swig_callbackOnInitialize = callbackOnInitialize; +} + +void SwigDirector_LayoutItemWrapperImpl::swig_init_callbacks() +{ + swig_callbackGetParent = 0; + swig_callbackOnUnparent = 0; + swig_callbackOnRegisterChildProperties = 0; + swig_callbackOnMeasure = 0; + swig_callbackOnLayout = 0; + swig_callbackOnSizeChanged = 0; + swig_callbackOnInitialize = 0; +} + + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemWrapperImpl() { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *result = 0 ; + + { + try { + result = (Dali::Toolkit::Internal::LayoutItem *)new SwigDirector_LayoutItemWrapperImpl(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_New(void * jarg1) { + void * jresult ; + Dali::Handle *arg1 = 0 ; + Dali::Toolkit::Internal::LayoutItemPtr result; + + arg1 = (Dali::Handle *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return 0; + } + { + try { + result = Dali::Toolkit::Internal::LayoutItem::New(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::Internal::LayoutItemPtr((const Dali::Toolkit::Internal::LayoutItemPtr &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_Initialize(void * jarg1, void * jarg2, char * jarg3) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + Dali::Handle *arg2 = 0 ; + std::string *arg3 = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + arg2 = (Dali::Handle *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return ; + } + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + { + try { + (arg1)->Initialize(*arg2,(std::string const &)*arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_Unparent(void * jarg1) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + (arg1)->Unparent(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SetAnimateLayout(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetAnimateLayout(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_IsLayoutAnimated(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = (bool)((Dali::Toolkit::Internal::LayoutItem const *)arg1)->IsLayoutAnimated(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_RegisterChildProperties(void * jarg1, char * jarg2) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + (arg1)->RegisterChildProperties((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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_Measure(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ; + Dali::Toolkit::MeasureSpec *argp2 ; + Dali::Toolkit::MeasureSpec *argp3 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + argp2 = (Dali::Toolkit::MeasureSpec *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasureSpec *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->Measure(arg2,arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_Layout(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ; + Dali::Toolkit::LayoutLength *argp2 ; + Dali::Toolkit::LayoutLength *argp3 ; + Dali::Toolkit::LayoutLength *argp4 ; + Dali::Toolkit::LayoutLength *argp5 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + argp2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::LayoutLength *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::Toolkit::LayoutLength *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg4 = *argp4; + argp5 = (Dali::Toolkit::LayoutLength *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg5 = *argp5; + { + try { + (arg1)->Layout(arg2,arg3,arg4,arg5); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetDefaultSize(void * jarg1, void * jarg2) { + void * jresult ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg1 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ; + Dali::Toolkit::LayoutLength *argp1 ; + Dali::Toolkit::MeasureSpec *argp2 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + argp1 = (Dali::Toolkit::LayoutLength *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Toolkit::MeasureSpec *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = Dali::Toolkit::Internal::LayoutItem::GetDefaultSize(arg1,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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetParent(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + Dali::Toolkit::Internal::LayoutParent *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = (Dali::Toolkit::Internal::LayoutParent *)(arg1)->GetParent(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetParentSwigExplicitLayoutItemWrapperImpl(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + Dali::Toolkit::Internal::LayoutParent *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = (Dali::Toolkit::Internal::LayoutParent *)(arg1)->Dali::Toolkit::Internal::LayoutItem::GetParent(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_RequestLayout(void * jarg1) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + (arg1)->RequestLayout(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_IsLayoutRequested(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = (bool)((Dali::Toolkit::Internal::LayoutItem const *)arg1)->IsLayoutRequested(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredWidth(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredWidth(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredHeight(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredHeight(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredWidthAndState(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + Dali::Toolkit::MeasuredSize result; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredWidthAndState(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::MeasuredSize((const Dali::Toolkit::MeasuredSize &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredHeightAndState(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + Dali::Toolkit::MeasuredSize result; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredHeightAndState(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::MeasuredSize((const Dali::Toolkit::MeasuredSize &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetSuggestedMinimumWidth(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetSuggestedMinimumWidth(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetSuggestedMinimumHeight(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetSuggestedMinimumHeight(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SetMinimumWidth(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ; + Dali::Toolkit::LayoutLength *argp2 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + argp2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetMinimumWidth(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SetMinimumHeight(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ; + Dali::Toolkit::LayoutLength *argp2 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + argp2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetMinimumHeight(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMinimumWidth(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMinimumWidth(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMinimumHeight(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMinimumHeight(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetPadding(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + Dali::Extents result; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetPadding(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Extents((const Dali::Extents &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SetMeasuredDimensions(void * jarg1, void * jarg2, void * jarg3) { + SwigDirector_LayoutItemWrapperImpl *arg1 = (SwigDirector_LayoutItemWrapperImpl *) 0 ; + Dali::Toolkit::MeasuredSize arg2 ; + Dali::Toolkit::MeasuredSize arg3 ; + Dali::Toolkit::MeasuredSize *argp2 ; + Dali::Toolkit::MeasuredSize *argp3 ; + + arg1 = (SwigDirector_LayoutItemWrapperImpl *)jarg1; + argp2 = (Dali::Toolkit::MeasuredSize *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasuredSize", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasuredSize *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasuredSize", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->SetMeasuredDimensions(arg2,arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnUnparent(void * jarg1) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnUnparent(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnUnparentSwigExplicitLayoutItemWrapperImpl(void * jarg1) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnUnparentSwigPublic(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnRegisterChildProperties(void * jarg1, char * jarg2) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + std::string *arg2 = 0 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnRegisterChildProperties((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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnRegisterChildPropertiesSwigExplicitLayoutItemWrapperImpl(void * jarg1, char * jarg2) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + std::string *arg2 = 0 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnRegisterChildPropertiesSwigPublic((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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnMeasure(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ; + Dali::Toolkit::MeasureSpec *argp2 ; + Dali::Toolkit::MeasureSpec *argp3 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + argp2 = (Dali::Toolkit::MeasureSpec *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasureSpec *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg3 = *argp3; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnMeasure(arg2,arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnMeasureSwigExplicitLayoutItemWrapperImpl(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ; + Dali::Toolkit::MeasureSpec *argp2 ; + Dali::Toolkit::MeasureSpec *argp3 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + argp2 = (Dali::Toolkit::MeasureSpec *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::MeasureSpec *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return ; + } + arg3 = *argp3; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnMeasureSwigPublic(arg2,arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnLayout(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + bool arg2 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg6 ; + Dali::Toolkit::LayoutLength *argp3 ; + Dali::Toolkit::LayoutLength *argp4 ; + Dali::Toolkit::LayoutLength *argp5 ; + Dali::Toolkit::LayoutLength *argp6 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + arg2 = jarg2 ? true : false; + argp3 = (Dali::Toolkit::LayoutLength *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::Toolkit::LayoutLength *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg4 = *argp4; + argp5 = (Dali::Toolkit::LayoutLength *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg5 = *argp5; + argp6 = (Dali::Toolkit::LayoutLength *)jarg6; + if (!argp6) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg6 = *argp6; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnLayout(arg2,arg3,arg4,arg5,arg6); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnLayoutSwigExplicitLayoutItemWrapperImpl(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + bool arg2 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg6 ; + Dali::Toolkit::LayoutLength *argp3 ; + Dali::Toolkit::LayoutLength *argp4 ; + Dali::Toolkit::LayoutLength *argp5 ; + Dali::Toolkit::LayoutLength *argp6 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + arg2 = jarg2 ? true : false; + argp3 = (Dali::Toolkit::LayoutLength *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::Toolkit::LayoutLength *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg4 = *argp4; + argp5 = (Dali::Toolkit::LayoutLength *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg5 = *argp5; + argp6 = (Dali::Toolkit::LayoutLength *)jarg6; + if (!argp6) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg6 = *argp6; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnLayoutSwigPublic(arg2,arg3,arg4,arg5,arg6); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnSizeChanged(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + Dali::Toolkit::LayoutSize arg2 ; + Dali::Toolkit::LayoutSize arg3 ; + Dali::Toolkit::LayoutSize *argp2 ; + Dali::Toolkit::LayoutSize *argp3 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + argp2 = (Dali::Toolkit::LayoutSize *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::LayoutSize *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0); + return ; + } + arg3 = *argp3; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnSizeChanged(arg2,arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnSizeChangedSwigExplicitLayoutItemWrapperImpl(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + Dali::Toolkit::LayoutSize arg2 ; + Dali::Toolkit::LayoutSize arg3 ; + Dali::Toolkit::LayoutSize *argp2 ; + Dali::Toolkit::LayoutSize *argp3 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + argp2 = (Dali::Toolkit::LayoutSize *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::LayoutSize *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0); + return ; + } + arg3 = *argp3; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnSizeChangedSwigPublic(arg2,arg3); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnInitialize(void * jarg1) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnInitialize(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnInitializeSwigExplicitLayoutItemWrapperImpl(void * jarg1) { + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + SwigDirector_LayoutItemWrapperImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + darg = dynamic_cast(arg1); + { + try { + (darg)->OnInitializeSwigPublic(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_director_connect(void *objarg, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback0_t callback0, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback1_t callback1, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback2_t callback2, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback3_t callback3, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback4_t callback4, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback5_t callback5, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback6_t callback6) { + Dali::Toolkit::Internal::LayoutItem *obj = (Dali::Toolkit::Internal::LayoutItem *)objarg; + SwigDirector_LayoutItemWrapperImpl *director = dynamic_cast(obj); + if (director) { + director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6); + } +} + +SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SWIGUpcast(Dali::Toolkit::Internal::LayoutItem *jarg1) { + return (Dali::BaseObject *)jarg1; +} + + +/*SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Toolkit::LayoutItem *arg1 = 0 ; + Dali::Toolkit::Internal::LayoutItem *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutItem *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutItem & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Internal::LayoutItem *) &Dali::Toolkit::GetImplementation(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +}*/ + +#ifdef __cplusplus +} +#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/layout-item-wrapper-impl.h b/dali-csharp-binder/src/layout-item-wrapper-impl.h new file mode 100644 index 0000000..19eb3c9 --- /dev/null +++ b/dali-csharp-binder/src/layout-item-wrapper-impl.h @@ -0,0 +1,82 @@ +#ifndef CSHARP_LAYOUT_ITEM_WRAPPER_IMPL_H +#define CSHARP_LAYOUT_ITEM_WRAPPER_IMPL_H + +/* + * 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. + * + */ + +#include "common.h" +#include + +class SwigDirector_LayoutItemWrapperImpl : public Dali::Toolkit::Internal::LayoutItem +{ +public: + SwigDirector_LayoutItemWrapperImpl(); + virtual ~SwigDirector_LayoutItemWrapperImpl(); + virtual Dali::Toolkit::Internal::LayoutParent *GetParent(); + virtual void OnUnparent(); + virtual void OnUnparentSwigPublic() + { + Dali::Toolkit::Internal::LayoutItem::OnUnparent(); + } + virtual void OnRegisterChildProperties(std::string const &containerType); + virtual void OnRegisterChildPropertiesSwigPublic(std::string const &containerType) + { + Dali::Toolkit::Internal::LayoutItem::OnRegisterChildProperties(containerType); + } + virtual void OnMeasure(Dali::Toolkit::MeasureSpec widthMeasureSpec, Dali::Toolkit::MeasureSpec heightMeasureSpec); + virtual void OnMeasureSwigPublic(Dali::Toolkit::MeasureSpec widthMeasureSpec, Dali::Toolkit::MeasureSpec heightMeasureSpec) + { + Dali::Toolkit::Internal::LayoutItem::OnMeasure(widthMeasureSpec,heightMeasureSpec); + } + virtual void OnLayout(bool changed, Dali::Toolkit::LayoutLength left, Dali::Toolkit::LayoutLength top, Dali::Toolkit::LayoutLength right, Dali::Toolkit::LayoutLength bottom); + virtual void OnLayoutSwigPublic(bool changed, Dali::Toolkit::LayoutLength left, Dali::Toolkit::LayoutLength top, Dali::Toolkit::LayoutLength right, Dali::Toolkit::LayoutLength bottom) + { + Dali::Toolkit::Internal::LayoutItem::OnLayout(changed,left,top,right,bottom); + } + virtual void OnSizeChanged(Dali::Toolkit::LayoutSize newSize, Dali::Toolkit::LayoutSize oldSize); + virtual void OnSizeChangedSwigPublic(Dali::Toolkit::LayoutSize newSize, Dali::Toolkit::LayoutSize oldSize) + { + Dali::Toolkit::Internal::LayoutItem::OnSizeChanged(newSize,oldSize); + } + virtual void OnInitialize(); + virtual void OnInitializeSwigPublic() + { + Dali::Toolkit::Internal::LayoutItem::OnInitialize(); + } + void SetMeasuredDimensions(Dali::Toolkit::MeasuredSize measuredWidth, Dali::Toolkit::MeasuredSize measuredHeight); + + typedef void * (SWIGSTDCALL* SWIG_Callback0_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback1_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback2_t)(char *); + typedef void (SWIGSTDCALL* SWIG_Callback3_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback4_t)(unsigned int, void *, void *, void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback5_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback6_t)(); + void swig_connect_director(SWIG_Callback0_t callbackGetParent, SWIG_Callback1_t callbackOnUnparent, SWIG_Callback2_t callbackOnRegisterChildProperties, SWIG_Callback3_t callbackOnMeasure, SWIG_Callback4_t callbackOnLayout, SWIG_Callback5_t callbackOnSizeChanged, SWIG_Callback6_t callbackOnInitialize); + +private: + SWIG_Callback0_t swig_callbackGetParent; + SWIG_Callback1_t swig_callbackOnUnparent; + SWIG_Callback2_t swig_callbackOnRegisterChildProperties; + SWIG_Callback3_t swig_callbackOnMeasure; + SWIG_Callback4_t swig_callbackOnLayout; + SWIG_Callback5_t swig_callbackOnSizeChanged; + SWIG_Callback6_t swig_callbackOnInitialize; + void swig_init_callbacks(); +}; + +#endif /* CSHARP_LAYOUT_ITEM_WRAPPER_IMPL_H */ diff --git a/dali-csharp-binder/src/layout-item-wrapper.cpp b/dali-csharp-binder/src/layout-item-wrapper.cpp new file mode 100755 index 0000000..b189992 --- /dev/null +++ b/dali-csharp-binder/src/layout-item-wrapper.cpp @@ -0,0 +1,383 @@ +/* + * 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. + * + */ + +#include "common.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutParent_GetParent(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutParent *arg1 = (Dali::Toolkit::Internal::LayoutParent *) 0 ; + Dali::Toolkit::Internal::LayoutParent *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutParent *)jarg1; + { + try { + result = (Dali::Toolkit::Internal::LayoutParent *)(arg1)->GetParent(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutItemWrapper_ChildProperty_WIDTH_SPECIFICATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutItemWrapper_ChildProperty_HEIGHT_SPECIFICATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemWrapper_ChildProperty() { + void * jresult ; + Dali::Toolkit::LayoutItem::ChildProperty *result = 0 ; + + { + try { + result = (Dali::Toolkit::LayoutItem::ChildProperty *)new Dali::Toolkit::LayoutItem::ChildProperty(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LayoutItemWrapper_ChildProperty(void * jarg1) { + Dali::Toolkit::LayoutItem::ChildProperty *arg1 = (Dali::Toolkit::LayoutItem::ChildProperty *) 0 ; + + arg1 = (Dali::Toolkit::LayoutItem::ChildProperty *)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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemWrapper__SWIG_0() { + void * jresult ; + Dali::Toolkit::LayoutItem *result = 0 ; + + { + try { + result = (Dali::Toolkit::LayoutItem *)new Dali::Toolkit::LayoutItem(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LayoutItemWrapper(void * jarg1) { + Dali::Toolkit::LayoutItem *arg1 = (Dali::Toolkit::LayoutItem *) 0 ; + + arg1 = (Dali::Toolkit::LayoutItem *)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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapper_New(void * jarg1) { + void * jresult ; + Dali::Handle *arg1 = 0 ; + Dali::Toolkit::LayoutItem result; + + arg1 = (Dali::Handle *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return 0; + } + { + try { + result = Dali::Toolkit::LayoutItem::New(*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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemWrapper__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::LayoutItem *arg1 = 0 ; + Dali::Toolkit::LayoutItem *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutItem *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutItem const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutItem *)new Dali::Toolkit::LayoutItem((Dali::Toolkit::LayoutItem 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapper_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::LayoutItem *arg1 = (Dali::Toolkit::LayoutItem *) 0 ; + Dali::Toolkit::LayoutItem *arg2 = 0 ; + Dali::Toolkit::LayoutItem *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutItem *)jarg1; + arg2 = (Dali::Toolkit::LayoutItem *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutItem const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutItem *) &(arg1)->operator =((Dali::Toolkit::LayoutItem 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapper_GetOwner(void * jarg1) { + void * jresult ; + Dali::Toolkit::LayoutItem *arg1 = (Dali::Toolkit::LayoutItem *) 0 ; + Dali::Handle result; + + arg1 = (Dali::Toolkit::LayoutItem *)jarg1; + { + try { + result = ((Dali::Toolkit::LayoutItem const *)arg1)->GetOwner(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Handle((const Dali::Handle &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapper_SetAnimateLayout(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::LayoutItem *arg1 = (Dali::Toolkit::LayoutItem *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::LayoutItem *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetAnimateLayout(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemWrapper_IsLayoutAnimated(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::LayoutItem *arg1 = (Dali::Toolkit::LayoutItem *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::LayoutItem *)jarg1; + { + try { + result = (bool)((Dali::Toolkit::LayoutItem const *)arg1)->IsLayoutAnimated(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemWrapper__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ; + Dali::Toolkit::LayoutItem *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1; + { + try { + result = (Dali::Toolkit::LayoutItem *)new Dali::Toolkit::LayoutItem(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_LayoutItemWrapper_SWIGUpcast(Dali::Toolkit::LayoutItem *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/src/layout-length.cpp b/dali-csharp-binder/src/layout-length.cpp new file mode 100755 index 0000000..2fefbf9 --- /dev/null +++ b/dali-csharp-binder/src/layout-length.cpp @@ -0,0 +1,776 @@ +/* + * 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. + * + */ + +#include "common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutLength__SWIG_0(int jarg1) { + void * jresult ; + Dali::Toolkit::LayoutLength::IntType arg1 ; + Dali::Toolkit::LayoutLength *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutLength::IntType)jarg1; + { + try { + result = (Dali::Toolkit::LayoutLength *)new Dali::Toolkit::LayoutLength(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutLength__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = 0 ; + Dali::Toolkit::LayoutLength *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutLength *)new Dali::Toolkit::LayoutLength((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength *arg2 = 0 ; + Dali::Toolkit::LayoutLength *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator =((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutLength_EqualTo__SWIG_0(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength *arg2 = 0 ; + bool result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->operator ==((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutLength_EqualTo__SWIG_1(void * jarg1, int jarg2) { + unsigned int jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + bool result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + { + try { + result = (bool)(arg1)->operator ==(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutLength_NotEqualTo(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength *arg2 = 0 ; + bool result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->operator !=((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutLength_LessThan__SWIG_0(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength *arg2 = 0 ; + bool result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->operator <((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutLength_GreaterThan__SWIG_0(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength *arg2 = 0 ; + bool result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try + { + // Umar:: To do Later/// + //result = (bool)(arg1)->operator >((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Add__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength *arg2 = 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->operator +((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Add__SWIG_1(void * jarg1, int jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + { + try { + result = (arg1)->operator +(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Subtract__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength *arg2 = 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->operator -((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Subtract__SWIG_1(void * jarg1, int jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + { + try { + result = (arg1)->operator -(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_AddAssign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength *arg2 = 0 ; + Dali::Toolkit::LayoutLength *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator +=((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_AddAssign__SWIG_1(void * jarg1, int jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + Dali::Toolkit::LayoutLength *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + { + try { + result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator +=(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_SubtractAssign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength *arg2 = 0 ; + Dali::Toolkit::LayoutLength *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator -=((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_SubtractAssign__SWIG_1(void * jarg1, int jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + Dali::Toolkit::LayoutLength *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + { + try { + result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator -=(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Divide__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength *arg2 = 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->operator /((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Divide__SWIG_1(void * jarg1, int jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + { + try { + result = (arg1)->operator /(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Multiply__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength *arg2 = 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->operator *((Dali::Toolkit::LayoutLength 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Multiply__SWIG_1(void * jarg1, int jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + { + try { + result = (arg1)->operator *(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Multiply__SWIG_2(void * jarg1, float jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + float arg2 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (arg1)->operator *(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_LayoutLength_ConvertToFloat(void * jarg1) { + float jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + float result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + { + try { + result = (float)(arg1)->operator float(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutLength_mValue_set(void * jarg1, int jarg2) { + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + if (arg1) (arg1)->mValue = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutLength_mValue_get(void * jarg1) { + int jresult ; + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + Dali::Toolkit::LayoutLength::IntType result; + + arg1 = (Dali::Toolkit::LayoutLength *)jarg1; + result = (Dali::Toolkit::LayoutLength::IntType) ((arg1)->mValue); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LayoutLength(void * jarg1) { + Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ; + + arg1 = (Dali::Toolkit::LayoutLength *)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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/src/layout-measure-spec.cpp b/dali-csharp-binder/src/layout-measure-spec.cpp new file mode 100755 index 0000000..bf33d20 --- /dev/null +++ b/dali-csharp-binder/src/layout-measure-spec.cpp @@ -0,0 +1,356 @@ +/* + * 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. + * + */ + +#include "common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_MeasureSpec__SWIG_0(void * jarg1, int jarg2) { + void * jresult ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg1 ; + Dali::Toolkit::MeasureSpec::Mode arg2 ; + Dali::Toolkit::LayoutLength *argp1 ; + Dali::Toolkit::MeasureSpec *result = 0 ; + + argp1 = (Dali::Toolkit::LayoutLength *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return 0; + } + arg1 = *argp1; + arg2 = (Dali::Toolkit::MeasureSpec::Mode)jarg2; + { + try { + result = (Dali::Toolkit::MeasureSpec *)new Dali::Toolkit::MeasureSpec(arg1,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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_MeasureSpec__SWIG_1(int jarg1) { + void * jresult ; + Dali::Toolkit::MeasureSpec::IntType arg1 ; + Dali::Toolkit::MeasureSpec *result = 0 ; + + arg1 = (Dali::Toolkit::MeasureSpec::IntType)jarg1; + { + try { + result = (Dali::Toolkit::MeasureSpec *)new Dali::Toolkit::MeasureSpec(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MeasureSpec(void * jarg1) { + Dali::Toolkit::MeasureSpec *arg1 = (Dali::Toolkit::MeasureSpec *) 0 ; + + arg1 = (Dali::Toolkit::MeasureSpec *)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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MeasureSpec_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::MeasureSpec *arg1 = (Dali::Toolkit::MeasureSpec *) 0 ; + Dali::Toolkit::MeasureSpec *arg2 = 0 ; + Dali::Toolkit::MeasureSpec *result = 0 ; + + arg1 = (Dali::Toolkit::MeasureSpec *)jarg1; + arg2 = (Dali::Toolkit::MeasureSpec *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::MeasureSpec const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::MeasureSpec *) &(arg1)->operator =((Dali::Toolkit::MeasureSpec 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MeasureSpec_EqualTo(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::MeasureSpec *arg1 = (Dali::Toolkit::MeasureSpec *) 0 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ; + Dali::Toolkit::MeasureSpec *argp2 ; + bool result; + + arg1 = (Dali::Toolkit::MeasureSpec *)jarg1; + argp2 = (Dali::Toolkit::MeasureSpec *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)(arg1)->operator ==(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MeasureSpec_NotEqualTo(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::MeasureSpec *arg1 = (Dali::Toolkit::MeasureSpec *) 0 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ; + Dali::Toolkit::MeasureSpec *argp2 ; + bool result; + + arg1 = (Dali::Toolkit::MeasureSpec *)jarg1; + argp2 = (Dali::Toolkit::MeasureSpec *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)(arg1)->operator !=(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MeasureSpec_GetMode(void * jarg1) { + int jresult ; + Dali::Toolkit::MeasureSpec *arg1 = (Dali::Toolkit::MeasureSpec *) 0 ; + Dali::Toolkit::MeasureSpec::Mode result; + + arg1 = (Dali::Toolkit::MeasureSpec *)jarg1; + { + try { + result = (Dali::Toolkit::MeasureSpec::Mode)((Dali::Toolkit::MeasureSpec const *)arg1)->GetMode(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MeasureSpec_GetSize(void * jarg1) { + int jresult ; + Dali::Toolkit::MeasureSpec *arg1 = (Dali::Toolkit::MeasureSpec *) 0 ; + Dali::Toolkit::MeasureSpec::IntType result; + + arg1 = (Dali::Toolkit::MeasureSpec *)jarg1; + { + try { + result = (Dali::Toolkit::MeasureSpec::IntType)((Dali::Toolkit::MeasureSpec const *)arg1)->GetSize(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MeasureSpec_Adjust(void * jarg1, int jarg2) { + void * jresult ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg1 ; + int arg2 ; + Dali::Toolkit::MeasureSpec *argp1 ; + SwigValueWrapper< Dali::Toolkit::MeasureSpec > result; + + argp1 = (Dali::Toolkit::MeasureSpec *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0); + return 0; + } + arg1 = *argp1; + arg2 = (int)jarg2; + { + try { + result = Dali::Toolkit::MeasureSpec::Adjust(arg1,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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MeasureSpec_mSize_set(void * jarg1, int jarg2) { + Dali::Toolkit::MeasureSpec *arg1 = (Dali::Toolkit::MeasureSpec *) 0 ; + Dali::Toolkit::MeasureSpec::IntType arg2 ; + + arg1 = (Dali::Toolkit::MeasureSpec *)jarg1; + arg2 = (Dali::Toolkit::MeasureSpec::IntType)jarg2; + if (arg1) (arg1)->mSize = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MeasureSpec_mSize_get(void * jarg1) { + int jresult ; + Dali::Toolkit::MeasureSpec *arg1 = (Dali::Toolkit::MeasureSpec *) 0 ; + Dali::Toolkit::MeasureSpec::IntType result; + + arg1 = (Dali::Toolkit::MeasureSpec *)jarg1; + result = (Dali::Toolkit::MeasureSpec::IntType) ((arg1)->mSize); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MeasureSpec_mMode_set(void * jarg1, int jarg2) { + Dali::Toolkit::MeasureSpec *arg1 = (Dali::Toolkit::MeasureSpec *) 0 ; + Dali::Toolkit::MeasureSpec::Mode arg2 ; + + arg1 = (Dali::Toolkit::MeasureSpec *)jarg1; + arg2 = (Dali::Toolkit::MeasureSpec::Mode)jarg2; + if (arg1) (arg1)->mMode = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MeasureSpec_mMode_get(void * jarg1) { + int jresult ; + Dali::Toolkit::MeasureSpec *arg1 = (Dali::Toolkit::MeasureSpec *) 0 ; + Dali::Toolkit::MeasureSpec::Mode result; + + arg1 = (Dali::Toolkit::MeasureSpec *)jarg1; + result = (Dali::Toolkit::MeasureSpec::Mode) ((arg1)->mMode); + jresult = (int)result; + return jresult; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/src/layout-measured-size.cpp b/dali-csharp-binder/src/layout-measured-size.cpp new file mode 100755 index 0000000..697d7a5 --- /dev/null +++ b/dali-csharp-binder/src/layout-measured-size.cpp @@ -0,0 +1,406 @@ +/* + * 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. + * + */ + +#include "common.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_MeasuredSize__SWIG_0() +{ + void * jresult ; + Dali::Toolkit::MeasuredSize *result = 0 ; + + try + { + result = (Dali::Toolkit::MeasuredSize *)new Dali::Toolkit::MeasuredSize(); + } + 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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_MeasuredSize__SWIG_1(void * jarg1) +{ + void * jresult ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg1 ; + Dali::Toolkit::LayoutLength *argp1 ; + Dali::Toolkit::MeasuredSize *result = 0 ; + + argp1 = (Dali::Toolkit::LayoutLength *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return 0; + } + arg1 = *argp1; + try + { + result = (Dali::Toolkit::MeasuredSize *)new Dali::Toolkit::MeasuredSize(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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_MeasuredSize__SWIG_2(void * jarg1, int jarg2) +{ + void * jresult ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg1 ; + Dali::Toolkit::MeasuredSize::State arg2 ; + Dali::Toolkit::LayoutLength *argp1 ; + Dali::Toolkit::MeasuredSize *result = 0 ; + + argp1 = (Dali::Toolkit::LayoutLength *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return 0; + } + arg1 = *argp1; + arg2 = (Dali::Toolkit::MeasuredSize::State)jarg2; + try + { + result = (Dali::Toolkit::MeasuredSize *)new Dali::Toolkit::MeasuredSize(arg1,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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MeasuredSize(void * jarg1) +{ + Dali::Toolkit::MeasuredSize *arg1 = (Dali::Toolkit::MeasuredSize *) 0 ; + + arg1 = (Dali::Toolkit::MeasuredSize *)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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MeasuredSize_Assign__SWIG_0(void * jarg1, void * jarg2) +{ + void * jresult ; + Dali::Toolkit::MeasuredSize *arg1 = (Dali::Toolkit::MeasuredSize *) 0 ; + Dali::Toolkit::MeasuredSize *arg2 = 0 ; + Dali::Toolkit::MeasuredSize *result = 0 ; + + arg1 = (Dali::Toolkit::MeasuredSize *)jarg1; + arg2 = (Dali::Toolkit::MeasuredSize *)jarg2; + if (!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::MeasuredSize const & type is null", 0); + return 0; + } + try + { + result = (Dali::Toolkit::MeasuredSize *) &(arg1)->operator =((Dali::Toolkit::MeasuredSize 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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MeasuredSize_Assign__SWIG_1(void * jarg1, int jarg2) +{ + void * jresult ; + Dali::Toolkit::MeasuredSize *arg1 = (Dali::Toolkit::MeasuredSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + Dali::Toolkit::MeasuredSize *result = 0 ; + + arg1 = (Dali::Toolkit::MeasuredSize *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + + try + { + result = (Dali::Toolkit::MeasuredSize *) &(arg1)->operator =(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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MeasuredSize_EqualTo(void * jarg1, void * jarg2) +{ + unsigned int jresult ; + Dali::Toolkit::MeasuredSize *arg1 = (Dali::Toolkit::MeasuredSize *) 0 ; + Dali::Toolkit::MeasuredSize arg2 ; + Dali::Toolkit::MeasuredSize *argp2 ; + bool result; + + arg1 = (Dali::Toolkit::MeasuredSize *)jarg1; + argp2 = (Dali::Toolkit::MeasuredSize *)jarg2; + if (!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasuredSize", 0); + return 0; + } + arg2 = *argp2; + try + { + result = (bool)(arg1)->operator ==(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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MeasuredSize_NotEqualTo(void * jarg1, void * jarg2) +{ + unsigned int jresult ; + Dali::Toolkit::MeasuredSize *arg1 = (Dali::Toolkit::MeasuredSize *) 0 ; + Dali::Toolkit::MeasuredSize arg2 ; + Dali::Toolkit::MeasuredSize *argp2 ; + bool result; + + arg1 = (Dali::Toolkit::MeasuredSize *)jarg1; + argp2 = (Dali::Toolkit::MeasuredSize *)jarg2; + if (!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasuredSize", 0); + return 0; + } + arg2 = *argp2; + try + { + result = (bool)(arg1)->operator !=(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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MeasuredSize_SetState(void * jarg1, int jarg2) +{ + Dali::Toolkit::MeasuredSize *arg1 = (Dali::Toolkit::MeasuredSize *) 0 ; + Dali::Toolkit::MeasuredSize::State arg2 ; + + arg1 = (Dali::Toolkit::MeasuredSize *)jarg1; + arg2 = (Dali::Toolkit::MeasuredSize::State)jarg2; + try + { + (arg1)->SetState(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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MeasuredSize_GetState(void * jarg1) +{ + int jresult ; + Dali::Toolkit::MeasuredSize *arg1 = (Dali::Toolkit::MeasuredSize *) 0 ; + Dali::Toolkit::MeasuredSize::State result; + + arg1 = (Dali::Toolkit::MeasuredSize *)jarg1; + try + { + result = (Dali::Toolkit::MeasuredSize::State)(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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MeasuredSize_SetSize(void * jarg1, void * jarg2) +{ + Dali::Toolkit::MeasuredSize *arg1 = (Dali::Toolkit::MeasuredSize *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ; + Dali::Toolkit::LayoutLength *argp2 ; + + arg1 = (Dali::Toolkit::MeasuredSize *)jarg1; + argp2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg2 = *argp2; + try + { + (arg1)->SetSize(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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MeasuredSize_GetSize(void * jarg1) +{ + void * jresult ; + Dali::Toolkit::MeasuredSize *arg1 = (Dali::Toolkit::MeasuredSize *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > result; + + arg1 = (Dali::Toolkit::MeasuredSize *)jarg1; + try + { + result = (arg1)->GetSize(); + } + 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 (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + } + jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result); + return jresult; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/src/layout-size.cpp b/dali-csharp-binder/src/layout-size.cpp new file mode 100755 index 0000000..1c0832d --- /dev/null +++ b/dali-csharp-binder/src/layout-size.cpp @@ -0,0 +1,444 @@ +/* + * 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. + * + */ + +#include "common.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutSize__SWIG_0() { + void * jresult ; + Dali::Toolkit::LayoutSize *result = 0 ; + + { + try { + result = (Dali::Toolkit::LayoutSize *)new Dali::Toolkit::LayoutSize(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutSize__SWIG_1(int jarg1, int jarg2) { + void * jresult ; + Dali::Toolkit::LayoutLength::IntType arg1 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + Dali::Toolkit::LayoutSize *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutLength::IntType)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + { + try { + result = (Dali::Toolkit::LayoutSize *)new Dali::Toolkit::LayoutSize(arg1,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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutSize__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Toolkit::LayoutSize *arg1 = 0 ; + Dali::Toolkit::LayoutSize *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutSize const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutSize *)new Dali::Toolkit::LayoutSize((Dali::Toolkit::LayoutSize 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutSize_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutSize *arg2 = 0 ; + Dali::Toolkit::LayoutSize *result = 0 ; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + arg2 = (Dali::Toolkit::LayoutSize *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutSize const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::LayoutSize *) &(arg1)->operator =((Dali::Toolkit::LayoutSize 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutSize_GetWidth(void * jarg1) { + int jresult ; + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType result; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + { + try { + result = (Dali::Toolkit::LayoutLength::IntType)(arg1)->GetWidth(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutSize_GetHeight(void * jarg1) { + int jresult ; + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType result; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + { + try { + result = (Dali::Toolkit::LayoutLength::IntType)(arg1)->GetHeight(); + } 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutSize_SetWidth__SWIG_0(void * jarg1, int jarg2) { + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + { + try { + (arg1)->SetWidth(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutSize_SetHeight__SWIG_0(void * jarg1, int jarg2) { + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + { + try { + (arg1)->SetHeight(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutSize_SetWidth__SWIG_1(void * jarg1, void * jarg2) { + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ; + Dali::Toolkit::LayoutLength *argp2 ; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + argp2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetWidth(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutSize_SetHeight__SWIG_1(void * jarg1, void * jarg2) { + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ; + Dali::Toolkit::LayoutLength *argp2 ; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + argp2 = (Dali::Toolkit::LayoutLength *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetHeight(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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutSize_EqualTo(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutSize *arg2 = 0 ; + bool result; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + arg2 = (Dali::Toolkit::LayoutSize *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutSize const & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->operator ==((Dali::Toolkit::LayoutSize 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 (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutSize_x_set(void * jarg1, int jarg2) { + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + if (arg1) (arg1)->x = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutSize_x_get(void * jarg1) { + int jresult ; + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType result; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + result = (Dali::Toolkit::LayoutLength::IntType) ((arg1)->x); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutSize_width_set(void * jarg1, int jarg2) { + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + if (arg1) (arg1)->width = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutSize_width_get(void * jarg1) { + int jresult ; + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType result; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + result = (Dali::Toolkit::LayoutLength::IntType) ((arg1)->width); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutSize_y_set(void * jarg1, int jarg2) { + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + if (arg1) (arg1)->y = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutSize_y_get(void * jarg1) { + int jresult ; + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType result; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + result = (Dali::Toolkit::LayoutLength::IntType) ((arg1)->y); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutSize_height_set(void * jarg1, int jarg2) { + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType arg2 ; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2; + if (arg1) (arg1)->height = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutSize_height_get(void * jarg1) { + int jresult ; + Dali::Toolkit::LayoutSize *arg1 = (Dali::Toolkit::LayoutSize *) 0 ; + Dali::Toolkit::LayoutLength::IntType result; + + arg1 = (Dali::Toolkit::LayoutSize *)jarg1; + result = (Dali::Toolkit::LayoutLength::IntType) ((arg1)->height); + jresult = result; + return jresult; +} + +#ifdef __cplusplus +} +#endif + -- 2.7.4