From: Umar Date: Mon, 17 Oct 2016 17:42:20 +0000 (+0100) Subject: C# CustomView Implementation (C++ wrappers, manual bindings, C# wrappers) X-Git-Tag: dali_1.2.15~7^2 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=commitdiff_plain;h=9f77c9e72e5601d52ad3da117b5679311c016028;hp=-c;ds=sidebyside C# CustomView Implementation (C++ wrappers, manual bindings, C# wrappers) Change-Id: I153b2861af8315ccdc64d01c5998790966213dc3 --- 9f77c9e72e5601d52ad3da117b5679311c016028 diff --git a/automated-tests/src/dali-toolkit/CMakeLists.txt b/automated-tests/src/dali-toolkit/CMakeLists.txt index f30e3d1..681d677 100644 --- a/automated-tests/src/dali-toolkit/CMakeLists.txt +++ b/automated-tests/src/dali-toolkit/CMakeLists.txt @@ -58,6 +58,7 @@ SET(TC_SOURCES utc-Dali-VideoView.cpp utc-Dali-AsyncImageLoader.cpp utc-Dali-SyncImageLoader.cpp + utc-Dali-ControlWrapper.cpp ) # Append list of test harness files (Won't get parsed for test cases) diff --git a/automated-tests/src/dali-toolkit/utc-Dali-ControlWrapper.cpp b/automated-tests/src/dali-toolkit/utc-Dali-ControlWrapper.cpp new file mode 100644 index 0000000..32076f1 --- /dev/null +++ b/automated-tests/src/dali-toolkit/utc-Dali-ControlWrapper.cpp @@ -0,0 +1,553 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include + +// Need to override adaptor classes for toolkit test harness, so include +// test harness headers before dali headers. +#include + +#include +#include +#include +#include +#include +#include + +using namespace Dali; +using namespace Dali::Toolkit; + +void utc_dali_toolkit_control_wrapper_startup(void) +{ + test_return_value = TET_UNDEF; +} + +void utc_dali_toolkit_control_wrapper_cleanup(void) +{ + test_return_value = TET_PASS; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +namespace +{ +bool gOnRelayout = false; +} // namespace + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +namespace Impl +{ +struct TestCustomControl : public Toolkit::Internal::ControlWrapper +{ + /** + * Constructor + */ + TestCustomControl() : Toolkit::Internal::ControlWrapper( CustomControlBehaviour( Toolkit::Internal::ControlWrapper::DISABLE_STYLE_CHANGE_SIGNALS | + Toolkit::Internal::ControlWrapper::REQUIRES_KEYBOARD_NAVIGATION_SUPPORT )) , + mDaliProperty( Property::INVALID_INDEX ), + mSizeSet( Vector3::ZERO ), + mTargetSize( Vector3::ZERO ), + mNego( false ), + mDepth( 0u ) + { + } + + TestCustomControl(bool nego) : Toolkit::Internal::ControlWrapper( CustomControlBehaviour( Toolkit::Internal::ControlWrapper::DISABLE_STYLE_CHANGE_SIGNALS | + Toolkit::Internal::ControlWrapper::REQUIRES_KEYBOARD_NAVIGATION_SUPPORT ) ), + mDaliProperty( Property::INVALID_INDEX ), + mSizeSet( Vector3::ZERO ), + mTargetSize( Vector3::ZERO ), + mNego( nego ) + { + } + /** + * Destructor + */ + virtual ~TestCustomControl() + { + } + + void Initialize( const char* name = NULL ) + { + mDaliProperty = Self().RegisterProperty( "Dali", std::string("no"), Property::READ_WRITE ); + + OnInitialize( name ); + } + + virtual void OnInitialize( const char* name ) {} + + // From Toolkit::Internal::ControlWrapper + virtual void OnStageConnection( int depth ) + { + mDepth = depth; + } + virtual void OnStageDisconnection() + { + } + virtual void OnChildAdd( Actor& child ) + { + } + virtual void OnChildRemove( Actor& child ) + { + } + virtual void OnPropertySet( Property::Index index, Property::Value propertyValue ) + { + } + virtual void OnSizeSet( const Vector3& targetSize ) + { + mSizeSet = targetSize; + } + virtual void OnSizeAnimation( Animation& animation, const Vector3& targetSize ) + { + mTargetSize = targetSize; + } + virtual bool OnTouchEvent( const TouchEvent& event ) + { + return true; + } + virtual bool OnHoverEvent( const HoverEvent& event ) + { + return true; + } + virtual bool OnWheelEvent( const WheelEvent& event ) + { + return true; + } + virtual bool OnKeyEvent( const KeyEvent& event ) + { + return true; + } + virtual void OnKeyInputFocusGained() + { + } + virtual void OnKeyInputFocusLost() + { + } + virtual Vector3 GetNaturalSize() + { + return Vector3( 0.0f, 0.0f, 0.0f ); + } + + virtual float GetHeightForWidth( float width ) + { + return 0.0f; + } + + virtual float GetWidthForHeight( float height ) + { + return 0.0f; + } + + virtual void OnRelayout( const Vector2& size, RelayoutContainer& container ) + { + gOnRelayout = true; + } + + virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension ) + { + } + + virtual void OnCalculateRelayoutSize( Dimension::Type dimension ) + { + } + + virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension ) + { + return 0.0f; + } + + virtual void OnLayoutNegotiated( float size, Dimension::Type dimension ) + { + } + + virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) + { + return false; + } + + void SetDaliProperty(std::string s) + { + Self().SetProperty(mDaliProperty, s); + } + void TestRelayoutRequest() + { + RelayoutRequest(); + } + + float TestGetHeightForWidthBase( float width ) + { + return GetHeightForWidthBase( width ); + } + + float TestGetWidthForHeightBase( float height ) + { + return GetWidthForHeightBase( height ); + } + + float TestCalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension ) + { + return CalculateChildSizeBase( child, dimension ); + } + + bool TestRelayoutDependentOnChildrenBase( Dimension::Type dimension ) + { + return RelayoutDependentOnChildrenBase( dimension ); + } + + Property::Index mDaliProperty; + Vector3 mSizeSet; + Vector3 mTargetSize; + bool mNego; + unsigned int mDepth; +}; +} + +int UtcDaliControlWrapperConstructor(void) +{ + ToolkitTestApplication application; // Exceptions require ToolkitTestApplication + + Toolkit::Internal::ControlWrapper* controlWrapperImpl = new Toolkit::Internal::ControlWrapper( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ); + ControlWrapper controlWrapper; + + DALI_TEST_CHECK( !ControlWrapper::DownCast( controlWrapper ) ); + + controlWrapper = ControlWrapper::New( *controlWrapperImpl ); + + DALI_TEST_CHECK( ControlWrapper::DownCast( controlWrapper ) ); + END_TEST; +} + +int UtcDaliControlWrapperDestructor(void) +{ + TestApplication application; + + ControlWrapper control = ControlWrapper::New( *( new Toolkit::Internal::ControlWrapper( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ) ) ); + + ControlWrapper control2( control ); + + DALI_TEST_CHECK( control ); + control.Reset(); + DALI_TEST_CHECK( !control ); + + DALI_TEST_CHECK( control2 ); + control2.Reset(); + DALI_TEST_CHECK( !control2 ); + + END_TEST; +} + +int UtcDaliControlWrapperRelayoutRequest(void) +{ + TestApplication application; + + DALI_TEST_EQUALS( gOnRelayout, false, TEST_LOCATION ); + + Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ); + ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl ); + + Stage::GetCurrent().Add( controlWrapper ); + + application.SendNotification(); + application.Render(); + + DALI_TEST_EQUALS( gOnRelayout, true, TEST_LOCATION ); + gOnRelayout = false; + + controlWrapperImpl->TestRelayoutRequest(); + application.SendNotification(); + application.Render(); + + DALI_TEST_EQUALS( gOnRelayout, true, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliControlWrapperImplGetHeightForWidthBase(void) +{ + TestApplication application; + + Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ); + ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl ); + + float width = 300.0f; + float v = 0.0f; + + application.SendNotification(); + application.Render(); + + v = controlWrapperImpl->TestGetHeightForWidthBase( width ); + + DALI_TEST_EQUALS( width, v, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliControlWrapperGetWidthForHeightBase(void) +{ + TestApplication application; + + Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ); + ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl ); + + float height = 300.0f; + float v = 0.0f; + + application.SendNotification(); + application.Render(); + + v = controlWrapperImpl->TestGetWidthForHeightBase( height ); + + DALI_TEST_EQUALS( height, v, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliControlWrapperCalculateChildSizeBase(void) +{ + TestApplication application; + + Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ); + ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl ); + + Actor child = Actor::New(); + child.SetResizePolicy( Dali::ResizePolicy::FIXED, Dali::Dimension::ALL_DIMENSIONS ); + child.SetSize(150, 150); + + application.SendNotification(); + application.Render(); + + float v = 9.99f; + v = controlWrapperImpl->TestCalculateChildSizeBase( child, Dali::Dimension::ALL_DIMENSIONS ); + DALI_TEST_EQUALS( v, 0.0f, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliControlWrapperRelayoutDependentOnChildrenBase(void) +{ + TestApplication application; + + Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ); + ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl ); + + bool v = false; + + v = controlWrapperImpl->TestRelayoutDependentOnChildrenBase( Dali::Dimension::ALL_DIMENSIONS ); + application.SendNotification(); + application.Render(); + + DALI_TEST_EQUALS( v, true, TEST_LOCATION ); + + controlWrapper.SetResizePolicy( Dali::ResizePolicy::FIXED, Dali::Dimension::ALL_DIMENSIONS ); + v = controlWrapperImpl->TestRelayoutDependentOnChildrenBase( Dali::Dimension::WIDTH ); + application.SendNotification(); + application.Render(); + DALI_TEST_EQUALS( v, false, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliControlWrapperRegisterVisualToSelf(void) +{ + ToolkitTestApplication application; + + Test::ObjectDestructionTracker objectDestructionTracker; + + { + Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ); + ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl ); + + objectDestructionTracker.Start( controlWrapper ); + + Property::Index index = 1; + + Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get(); + Toolkit::Visual::Base visual; + + Property::Map map; + map[Visual::Property::TYPE] = Visual::COLOR; + map[ColorVisual::Property::MIX_COLOR] = Color::RED; + + visual = visualFactory.CreateVisual( map ); + DALI_TEST_CHECK( visual ); + + // Register to self + controlWrapperImpl->RegisterVisual( index, visual ); + + DALI_TEST_EQUALS( objectDestructionTracker.IsDestroyed(), false, TEST_LOCATION ); // Control not destroyed yet + DALI_TEST_EQUALS( controlWrapperImpl->GetVisual( index ), visual, TEST_LOCATION ); + } + + DALI_TEST_EQUALS( objectDestructionTracker.IsDestroyed(), true, TEST_LOCATION ); // Should be destroyed + + END_TEST; +} + +int UtcDaliControlWrapperRegisterDisabledVisual(void) +{ + ToolkitTestApplication application; + + Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ); + ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl ); + + Property::Index TEST_PROPERTY = 1; + + Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get(); + Toolkit::Visual::Base visual; + + Property::Map map; + map[Visual::Property::TYPE] = Visual::COLOR; + map[ColorVisual::Property::MIX_COLOR] = Color::RED; + + visual = visualFactory.CreateVisual( map ); + DALI_TEST_CHECK(visual); + + // Register index with a color visual + controlWrapperImpl->RegisterVisual( TEST_PROPERTY, visual, false ); + + DALI_TEST_EQUALS( controlWrapperImpl->GetVisual( TEST_PROPERTY ), visual, TEST_LOCATION ); + DALI_TEST_EQUALS( controlWrapperImpl->IsVisualEnabled( TEST_PROPERTY ), false, TEST_LOCATION ); + + Stage::GetCurrent().Add( controlWrapper ); + + // Render and notify + application.SendNotification(); + application.Render(); + + DALI_TEST_EQUALS( controlWrapperImpl->IsVisualEnabled( TEST_PROPERTY ), false, TEST_LOCATION ); + + DALI_TEST_EQUALS( controlWrapper.OnStage(), true, TEST_LOCATION ); + + controlWrapperImpl->EnableVisual( TEST_PROPERTY, true ); + + DALI_TEST_EQUALS( controlWrapperImpl->IsVisualEnabled( TEST_PROPERTY ), true, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliControlWrapperRegisterUnregisterVisual(void) +{ + ToolkitTestApplication application; + + Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ); + ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl ); + + Property::Index index = 1; + + Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get(); + Toolkit::Visual::Base visual; + + Property::Map map; + map[Visual::Property::TYPE] = Visual::COLOR; + map[ColorVisual::Property::MIX_COLOR] = Color::RED; + + visual = visualFactory.CreateVisual( map ); + DALI_TEST_CHECK(visual); + + // Register index with a color visual + controlWrapperImpl->RegisterVisual( index, visual ); + + DALI_TEST_EQUALS( controlWrapperImpl->GetVisual( index ), visual, TEST_LOCATION ); + + // Unregister visual + controlWrapperImpl->UnregisterVisual( index ); + + DALI_TEST_CHECK( !controlWrapperImpl->GetVisual( index ) ); + + END_TEST; +} + +int UtcDaliControlWrapperTransitionDataMap1N(void) +{ + TestApplication application; + + Property::Map map; + map["target"] = "Actor1"; + map["property"] = "randomProperty"; + map["initialValue"] = Color::MAGENTA; + map["targetValue"] = Color::RED; + map["animator"] = Property::Map() + .Add("alphaFunction", "EASE_OUT") + .Add("timePeriod", Property::Map() + .Add("delay", 0.5f) + .Add("duration", 1.0f)); + + Dali::Toolkit::TransitionData transition = TransitionData::New( map ); + + Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ); + ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl ); + + //DummyControl actor = DummyControl::New(); + controlWrapper.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS); + controlWrapper.SetName("Actor1"); + controlWrapper.SetColor(Color::CYAN); + Stage::GetCurrent().Add(controlWrapper); + + Animation anim = controlWrapperImpl->CreateTransition( transition ); + DALI_TEST_CHECK( ! anim ); + + Property::Map returnedMap = transition.GetAnimatorAt(0); + + Property::Value* value = returnedMap.Find("property"); + DALI_TEST_CHECK( value != NULL); + DALI_TEST_EQUALS( "randomProperty", value->Get(), TEST_LOCATION ); + + value = returnedMap.Find("initialValue"); + DALI_TEST_CHECK( value != NULL); + DALI_TEST_EQUALS( Color::MAGENTA, value->Get(), TEST_LOCATION ); + + value = returnedMap.Find("targetValue"); + DALI_TEST_CHECK( value != NULL); + DALI_TEST_EQUALS( Color::RED, value->Get(), TEST_LOCATION ); + + value = returnedMap.Find("animator"); + DALI_TEST_CHECK( value != NULL); + Property::Map returnedAnimatorMap = value->Get(); + + value = returnedAnimatorMap.Find("alphaFunction"); + DALI_TEST_CHECK( value != NULL); + DALI_TEST_EQUALS( "EASE_OUT", value->Get(), TEST_LOCATION ); + + value = returnedAnimatorMap.Find("timePeriod"); + DALI_TEST_CHECK( value != NULL); + Property::Map returnedTimePeriodMap = value->Get(); + + value = returnedTimePeriodMap.Find("delay"); + DALI_TEST_CHECK( value != NULL); + DALI_TEST_EQUALS( 0.5f, value->Get(), TEST_LOCATION ); + + value = returnedTimePeriodMap.Find("duration"); + DALI_TEST_CHECK( value != NULL); + DALI_TEST_EQUALS( 1.0f, value->Get(), TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliControlWrapperApplyThemeStyle(void) +{ + ToolkitTestApplication application; + + Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ); + ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl ); + + controlWrapperImpl->ApplyThemeStyle(); + + DALI_TEST_CHECK( true ); + END_TEST; +} diff --git a/build/tizen/plugins/csharp/Makefile.am b/build/tizen/plugins/csharp/Makefile.am index 5e7263b..8aa499a 100755 --- a/build/tizen/plugins/csharp/Makefile.am +++ b/build/tizen/plugins/csharp/Makefile.am @@ -16,19 +16,24 @@ dali_swig_dir = ../../../../plugins/dali-swig BUILT_SOURCES = \ $(dali_swig_dir)/automatic/cpp/dali_wrap.cpp \ - $(dali_swig_dir)/automatic/cpp/dali_wrap.h + $(dali_swig_dir)/automatic/cpp/dali_wrap.h \ + $(dali_swig_dir)/manual/cpp/keyboard_focus_manager_wrap.cpp \ + $(dali_swig_dir)/manual/cpp/view-wrapper-impl-wrap.cpp -all-local: +all-local: gbs-local: libNDalic.so NDali.dll -libNDalic.so: $(dali_swig_dir)/automatic/cpp/dali_wrap.o $(dali_swig_dir)/manual/cpp/dali_wrap_manual.o - $(CXX) -shared $(dali_swig_dir)/automatic/cpp/dali_wrap.o $(dali_swig_dir)/manual/cpp/dali_wrap_manual.o -o $(dali_swig_dir)/libNDalic.so $(DALICORE_LIBS) $(DALIADAPTOR_LIBS) $(DALITOOLKIT_LIBS) +libNDalic.so: $(dali_swig_dir)/automatic/cpp/dali_wrap.o $(dali_swig_dir)/manual/cpp/keyboard_focus_manager_wrap.o $(dali_swig_dir)/manual/cpp/view-wrapper-impl-wrap.o + $(CXX) -shared $(dali_swig_dir)/automatic/cpp/dali_wrap.o $(dali_swig_dir)/manual/cpp/keyboard_focus_manager_wrap.o $(dali_swig_dir)/manual/cpp/view-wrapper-impl-wrap.o -o $(dali_swig_dir)/libNDalic.so $(DALICORE_LIBS) $(DALIADAPTOR_LIBS) $(DALITOOLKIT_LIBS) $(dali_swig_dir)/automatic/cpp/dali_wrap.o: $(BUILT_SOURCES) $(CXX) -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) $(dali_swig_dir)/automatic/cpp/dali_wrap.cpp -o $(dali_swig_dir)/automatic/cpp/dali_wrap.o -$(dali_swig_dir)/manual/cpp/dali_wrap_manual.o: $(BUILT_SOURCES) - $(CXX) -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) $(dali_swig_dir)/manual/cpp/keyboard_focus_manager_wrap.cpp -o $(dali_swig_dir)/manual/cpp/dali_wrap_manual.o +$(dali_swig_dir)/manual/cpp/keyboard_focus_manager_wrap.o: $(BUILT_SOURCES) + $(CXX) -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) $(dali_swig_dir)/manual/cpp/keyboard_focus_manager_wrap.cpp -o $(dali_swig_dir)/manual/cpp/keyboard_focus_manager_wrap.o + +$(dali_swig_dir)/manual/cpp/view-wrapper-impl-wrap.o: $(BUILT_SOURCES) + $(CXX) -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) $(dali_swig_dir)/manual/cpp/view-wrapper-impl-wrap.cpp -o $(dali_swig_dir)/manual/cpp/view-wrapper-impl-wrap.o NDali.dll: $(BUILT_SOURCES) # mcs -nologo -target:library -out:$(dali_swig_dir)/NDali.dll $(dali_swig_dir)/automatic/csharp/*.cs $(dali_swig_dir)/manual/csharp/*.cs diff --git a/dali-toolkit/devel-api/controls/control-wrapper-impl.cpp b/dali-toolkit/devel-api/controls/control-wrapper-impl.cpp new file mode 100755 index 0000000..48019fe --- /dev/null +++ b/dali-toolkit/devel-api/controls/control-wrapper-impl.cpp @@ -0,0 +1,142 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// CLASS HEADER +#include + +// INTERNAL INCLUDES +#include +#include +#include +#include +#include + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Internal +{ + +/* + * Implementation. + */ + +Dali::Toolkit::ControlWrapper ControlWrapper::New( ControlWrapper* controlWrapper ) +{ + ControlWrapperPtr wrapper( controlWrapper ); + + // Pass ownership to CustomActor via derived handle. + Dali::Toolkit::ControlWrapper handle( *wrapper ); + + // Second-phase initialisation of the implementation. + // This can only be done after the CustomActor connection has been made. + wrapper->Initialize(); + + return handle; +} + +ControlWrapper::ControlWrapper( CustomControlBehaviour behaviourFlags ) +: Control( static_cast< ControlBehaviour >( behaviourFlags ) ) +{ +} + +ControlWrapper::~ControlWrapper() +{ +} + +void ControlWrapper::RelayoutRequest() +{ + CustomActorImpl::RelayoutRequest(); +} + +float ControlWrapper::GetHeightForWidthBase( float width ) +{ + return CustomActorImpl::GetHeightForWidthBase( width ); +} + +float ControlWrapper::GetWidthForHeightBase( float height ) +{ + return CustomActorImpl::GetWidthForHeightBase( height ); +} + +float ControlWrapper::CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension ) +{ + return CustomActorImpl::CalculateChildSizeBase( child, dimension ); +} + +bool ControlWrapper::RelayoutDependentOnChildrenBase( Dimension::Type dimension ) +{ + return CustomActorImpl::RelayoutDependentOnChildrenBase( dimension ); +} + +void ControlWrapper::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual ) +{ + Control::RegisterVisual( index, visual ); +} + +void ControlWrapper::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, bool enabled ) +{ + Control::RegisterVisual( index, visual, enabled ); +} + +void ControlWrapper::UnregisterVisual( Property::Index index ) +{ + Control::UnregisterVisual( index ); +} + +Toolkit::Visual::Base ControlWrapper::GetVisual( Property::Index index ) const +{ + return Control::GetVisual( index ); +} + +void ControlWrapper::EnableVisual( Property::Index index, bool enable ) +{ + Control::EnableVisual( index, enable ); +} + +bool ControlWrapper::IsVisualEnabled( Property::Index index ) const +{ + return Control::IsVisualEnabled( index ); +} + +Dali::Animation ControlWrapper::CreateTransition( const Toolkit::TransitionData& handle ) +{ + return Control::CreateTransition( handle ); +} + +void ControlWrapper::ApplyThemeStyle() +{ + Toolkit::StyleManager styleManager = StyleManager::Get(); + + // if style manager is available + if( styleManager ) + { + StyleManager& styleManagerImpl = GetImpl( styleManager ); + + // Apply the current style + styleManagerImpl.ApplyThemeStyle( Toolkit::Control( GetOwner() ) ); + } +} + +} // namespace Internal + +} // namespace Toolkit + +} // namespace Dali diff --git a/dali-toolkit/devel-api/controls/control-wrapper-impl.h b/dali-toolkit/devel-api/controls/control-wrapper-impl.h new file mode 100755 index 0000000..787fa89 --- /dev/null +++ b/dali-toolkit/devel-api/controls/control-wrapper-impl.h @@ -0,0 +1,194 @@ +#ifndef DALI_TOOLKIT_INTERNAL_CONTROL_WRAPPER_H +#define DALI_TOOLKIT_INTERNAL_CONTROL_WRAPPER_H + +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// INTERNAL INCLUDES +#include +#include + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Internal +{ + +class ControlWrapper; + +typedef IntrusivePtr< ControlWrapper > ControlWrapperPtr; + +/** + * @copydoc Toolkit::ControlWrapper + */ +class ControlWrapper : public Control +{ +public: + + // Flags for the constructor + enum CustomControlBehaviour + { + CONTROL_BEHAVIOUR_DEFAULT = Control::CONTROL_BEHAVIOUR_DEFAULT, + DISABLE_SIZE_NEGOTIATION = CustomActorImpl::DISABLE_SIZE_NEGOTIATION, + REQUIRES_KEYBOARD_NAVIGATION_SUPPORT = Control::REQUIRES_KEYBOARD_NAVIGATION_SUPPORT, + DISABLE_STYLE_CHANGE_SIGNALS = Control::DISABLE_STYLE_CHANGE_SIGNALS, + + LAST_CONTROL_BEHAVIOUR_FLAG + }; + + static const int CONTROL_BEHAVIOUR_FLAG_COUNT = Log< LAST_CONTROL_BEHAVIOUR_FLAG - 1 >::value + 1; ///< Total count of flags + + /** + * @brief Control constructor + * + * @param[in] behaviourFlags Behavioural flags from CustomControlBehaviour enum + */ + ControlWrapper( CustomControlBehaviour behaviourFlags ); + + /** + * Create a new ControlWrapper. + * @return A public handle to the newly allocated ControlWrapper. + */ + static Dali::Toolkit::ControlWrapper New( ControlWrapper* controlWrapper ); + +public: // From CustomActorImpl + + // Size negotiation helpers + + /** + * @copydoc Dali::CustomActorImpl::RelayoutRequest() + */ + void RelayoutRequest(); + + /** + * @copydoc Dali::CustomActorImpl::GetHeightForWidthBase() + */ + float GetHeightForWidthBase( float width ); + + /** + * @copydoc Dali::CustomActorImpl::GetWidthForHeightBase() + */ + float GetWidthForHeightBase( float height ); + + /** + * @copydoc Dali::CustomActorImpl::CalculateChildSizeBase() + */ + float CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension ); + + /** + * @copydoc Dali::CustomActorImpl::RelayoutDependentOnChildrenBase() + */ + bool RelayoutDependentOnChildrenBase( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ); + +public: // From Control + + /** + * @copydoc Dali::Toolkit::Internal::Control::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual ) + */ + void RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual ); + + /** + * @copydoc Dali::Toolkit::Internal::Control::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, bool enabled ) + */ + void RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, bool enabled ); + + /** + * @copydoc Dali::Toolkit::Internal::Control::UnregisterVisual() + */ + void UnregisterVisual( Property::Index index ); + + /** + * @copydoc Dali::Toolkit::Internal::Control::GetVisual() + */ + Toolkit::Visual::Base GetVisual( Property::Index index ) const; + + /** + * @copydoc Dali::Toolkit::Internal::Control::EnableVisual() + */ + void EnableVisual( Property::Index index, bool enable ); + + /** + * @copydoc Dali::Toolkit::Internal::Control::IsVisualEnabled() + */ + bool IsVisualEnabled( Property::Index index ) const; + + /** + * @copydoc Dali::Toolkit::Internal::Control::CreateTransition() + */ + Dali::Animation CreateTransition( const Toolkit::TransitionData& transitionData ); + + /** + * @copydoc Dali::Toolkit::Internal::Control::EmitKeyInputFocusSignal() + */ + void EmitKeyInputFocusSignal( bool focusGained ); + + /** + * @brief Apply the current style + * + * This method is called after the Control has been initialized. + * + */ + void ApplyThemeStyle(); + +protected: + + /** + * Protected Destructor + * A reference counted object may only be deleted by calling Unreference() + */ + virtual ~ControlWrapper(); + +private: + + // Undefined. + ControlWrapper( const ControlWrapper& ); + + // Undefined. + ControlWrapper& operator=( const ControlWrapper& rhs ); + +}; + +} // namespace Internal + +// Helpers for public-api forwarding methods + +inline Toolkit::Internal::ControlWrapper& GetControlWrapperImpl( Toolkit::ControlWrapper& publicObject ) +{ + DALI_ASSERT_ALWAYS( publicObject ); + + Dali::RefObject& handle = publicObject.GetImplementation(); + + return static_cast( handle ); +} + +inline const Toolkit::Internal::ControlWrapper& GetControlWrapperImpl( const Toolkit::ControlWrapper& publicObject ) +{ + DALI_ASSERT_ALWAYS( publicObject ); + + const Dali::RefObject& handle = publicObject.GetImplementation(); + + return static_cast( handle ); +} + +} // namespace Toolkit + +} // namespace Dali + +#endif // DALI_TOOLKIT_INTERNAL_CONTROL_WRAPPER_H diff --git a/dali-toolkit/devel-api/controls/control-wrapper.cpp b/dali-toolkit/devel-api/controls/control-wrapper.cpp new file mode 100644 index 0000000..7f8db27 --- /dev/null +++ b/dali-toolkit/devel-api/controls/control-wrapper.cpp @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// CLASS HEADER +#include + +// INTERNAL INCLUDES +#include + +namespace Dali +{ + +namespace Toolkit +{ + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// ControlWrapper +/////////////////////////////////////////////////////////////////////////////////////////////////// + +ControlWrapper ControlWrapper::New( Internal::ControlWrapper& implementation ) +{ + return Internal::ControlWrapper::New( &implementation ); +} + +ControlWrapper::ControlWrapper() +{ +} + +ControlWrapper::ControlWrapper( const ControlWrapper& handle ) +: Control( handle ) +{ +} + +ControlWrapper& ControlWrapper::operator=( const ControlWrapper& handle ) +{ + if( &handle != this ) + { + Control::operator=( handle ); + } + return *this; +} + +ControlWrapper::ControlWrapper( Internal::ControlWrapper& implementation ) +: Control( implementation ) +{ +} + +ControlWrapper::ControlWrapper( Dali::Internal::CustomActor* internal ) +: Control( internal ) +{ + VerifyCustomActorPointer( internal ); +} + +ControlWrapper::~ControlWrapper() +{ +} + +ControlWrapper ControlWrapper::DownCast( BaseHandle handle ) +{ + return Control::DownCast( handle ); +} + +} // namespace Toolkit + +} // namespace Dali diff --git a/dali-toolkit/devel-api/controls/control-wrapper.h b/dali-toolkit/devel-api/controls/control-wrapper.h new file mode 100644 index 0000000..a9aacc5 --- /dev/null +++ b/dali-toolkit/devel-api/controls/control-wrapper.h @@ -0,0 +1,112 @@ +#ifndef DALI_TOOLKIT_CONTROL_WRAPPER_H +#define DALI_TOOLKIT_CONTROL_WRAPPER_H + +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// INTERNAL INCLUDES +#include + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Internal DALI_INTERNAL +{ +class ControlWrapper; +} + +/** + * @brief ControlWrapper is a base class for custom UI controls developed in managed code (i.e. C#.NET). + * + * The implementation of the ControlWrapper must be supplied; see Internal::ControlWrapper for more details. + */ +class DALI_IMPORT_API ControlWrapper : public Control +{ + +public: + + /** + * @brief Create a new instance of a ControlWrapper. + * + * @return A handle to a new ControlWrapper. + */ + static ControlWrapper New( Internal::ControlWrapper& implementation ); + + /** + * @brief Creates an empty ControlWrapper handle. + */ + ControlWrapper(); + + /** + * @brief Destructor + * + * This is non-virtual since derived Handle types must not contain data or virtual methods. + */ + ~ControlWrapper(); + + /** + * @brief Copy constructor. + * + * Creates another handle that points to the same real object + * @param[in] handle Handle to the copied object + */ + ControlWrapper( const ControlWrapper& handle ); + + /** + * @brief Assignment operator. + * + * Changes this handle to point to another real object + * @param[in] handle Handle to the object + * @return A reference to this + */ + ControlWrapper& operator=( const ControlWrapper& handle ); + + /** + * @brief Downcast an Object handle to ControlWrapper. + * + * If handle points to a ControlWrapper the + * downcast produces valid handle. If not the returned handle is left uninitialized. + * @param[in] handle Handle to an object + * @return handle to a ControlWrapper or an uninitialized handle + */ + static ControlWrapper DownCast( BaseHandle handle ); + +public: // Not intended for application developers + + /** + * @brief Creates a handle using the Toolkit::Internal implementation. + * + * @param[in] implementation The Control implementation. + */ + DALI_INTERNAL ControlWrapper( Internal::ControlWrapper& implementation ); + + /** + * @brief Allows the creation of this Control from an Internal::CustomActor pointer. + * + * @param[in] internal A pointer to the internal CustomActor. + */ + explicit DALI_INTERNAL ControlWrapper( Dali::Internal::CustomActor* internal ); +}; + +} // namespace Toolkit + +} // namespace Dali + +#endif // DALI_TOOLKIT_CONTROL_WRAPPER_H diff --git a/dali-toolkit/devel-api/file.list b/dali-toolkit/devel-api/file.list index 8af4766..a0cd28a 100755 --- a/dali-toolkit/devel-api/file.list +++ b/dali-toolkit/devel-api/file.list @@ -4,6 +4,8 @@ devel_api_src_files = \ $(devel_api_src_dir)/builder/builder.cpp \ $(devel_api_src_dir)/builder/json-parser.cpp \ $(devel_api_src_dir)/builder/tree-node.cpp \ + $(devel_api_src_dir)/controls/control-wrapper.cpp \ + $(devel_api_src_dir)/controls/control-wrapper-impl.cpp \ $(devel_api_src_dir)/controls/bloom-view/bloom-view.cpp \ $(devel_api_src_dir)/controls/bubble-effect/bubble-emitter.cpp \ $(devel_api_src_dir)/controls/effects-view/effects-view.cpp \ @@ -39,7 +41,9 @@ devel_api_header_files = \ $(devel_api_src_dir)/align-enums.h devel_api_controls_header_files = \ - $(devel_api_src_dir)/controls/control-depth-index-ranges.h + $(devel_api_src_dir)/controls/control-depth-index-ranges.h \ + $(devel_api_src_dir)/controls/control-wrapper.h \ + $(devel_api_src_dir)/controls/control-wrapper-impl.h devel_api_bloom_view_header_files = \ $(devel_api_src_dir)/controls/bloom-view/bloom-view.h diff --git a/plugins/dali-swig/Makefile.am b/plugins/dali-swig/Makefile.am index 9a4c8d6..9ed6c33 100644 --- a/plugins/dali-swig/Makefile.am +++ b/plugins/dali-swig/Makefile.am @@ -23,8 +23,8 @@ if BUILD_MCS all-local: libNDalic.so NDali.dll -libNDalic.so: automatic/cpp/dali_wrap.o manual/cpp/keyboard_focus_manager_wrap.o - g++ -shared automatic/cpp/dali_wrap.o manual/cpp/keyboard_focus_manager_wrap.o -o libNDalic.so $(DALICORE_LIBS) $(DALIADAPTOR_LIBS) $(DALITOOLKIT_LIBS) +libNDalic.so: automatic/cpp/dali_wrap.o manual/cpp/keyboard_focus_manager_wrap.o manual/cpp/view-wrapper-impl-wrap.o + g++ -shared automatic/cpp/dali_wrap.o manual/cpp/keyboard_focus_manager_wrap.o manual/cpp/view-wrapper-impl-wrap.o -o libNDalic.so $(DALICORE_LIBS) $(DALIADAPTOR_LIBS) $(DALITOOLKIT_LIBS) automatic/cpp/dali_wrap.o: $(BUILT_SOURCES) g++ -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) automatic/cpp/dali_wrap.cpp -o automatic/cpp/dali_wrap.o @@ -32,12 +32,17 @@ automatic/cpp/dali_wrap.o: $(BUILT_SOURCES) manual/cpp/keyboard_focus_manager_wrap.o: $(BUILT_SOURCES) g++ -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) manual/cpp/keyboard_focus_manager_wrap.cpp -o manual/cpp/keyboard_focus_manager_wrap.o +manual/cpp/view-wrapper-impl-wrap.o: $(BUILT_SOURCES) + g++ -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) manual/cpp/view-wrapper-impl-wrap.cpp -o manual/cpp/view-wrapper-impl-wrap.o + NDali.dll: $(BUILT_SOURCES) $(MCS) -nologo -target:library -out:NDali.dll automatic/csharp/*.cs manual/csharp/*.cs check-local: examples/dali-test.exe \ examples/hello-world.exe \ examples/scroll-view.exe \ + examples/custom-control.exe \ + examples/spin-control.exe \ examples/libNDalic.so examples/NDali.dll examples/%.exe: examples/%.cs diff --git a/plugins/dali-swig/NDali.dll b/plugins/dali-swig/NDali.dll index 34c673b..4fbbfa4 100755 Binary files a/plugins/dali-swig/NDali.dll and b/plugins/dali-swig/NDali.dll differ diff --git a/plugins/dali-swig/SWIG/dali-toolkit.i b/plugins/dali-swig/SWIG/dali-toolkit.i index cfa1c57..c9f585d 100644 --- a/plugins/dali-swig/SWIG/dali-toolkit.i +++ b/plugins/dali-swig/SWIG/dali-toolkit.i @@ -24,6 +24,8 @@ %ignore *::CheckBoxButton(Internal::CheckBoxButton&); %ignore *::CheckBoxButton(Dali::Internal::CustomActor*); %ignore *::Control(Dali::Internal::CustomActor*); +%ignore *::ControlWrapper( Internal::ControlWrapper& ); +%ignore *::ControlWrapper( Dali::Internal::CustomActor* ); %ignore *::FlexContainer(Internal::FlexContainer&); %ignore *::FlexContainer(Dali::Internal::CustomActor*); %ignore *::GaussianBlurView(Internal::GaussianBlurView&); @@ -158,8 +160,15 @@ %csconstvalue("PropertyRanges.ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX") ANIMATABLE_PROPERTY_START_INDEX; %csconstvalue("PropertyRanges.ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX+1000") ANIMATABLE_PROPERTY_END_INDEX; %csconstvalue("PropertyRanges.CORE_PROPERTY_MAX_INDEX+1") VISUAL_PROPERTY_BASE_START_INDEX; -%csconstvalue("1 << 5") REQUIRES_STYLE_CHANGE_SIGNALS; -%csconstvalue("1 << 6") REQUIRES_KEYBOARD_NAVIGATION_SUPPORT; +%csconstvalue("0") CONTROL_BEHAVIOUR_NONE; +%csconstvalue("0") CONTROL_BEHAVIOUR_DEFAULT; +%csconstvalue("1 << 0") DISABLE_SIZE_NEGOTIATION; +%csconstvalue("1 << 1") REQUIRES_TOUCH_EVENTS; +%csconstvalue("1 << 2") REQUIRES_HOVER_EVENTS; +%csconstvalue("1 << 3") REQUIRES_WHEEL_EVENTS; +%csconstvalue("1 << 4") REQUIRES_STYLE_CHANGE_SIGNALS; +%csconstvalue("1 << 5") REQUIRES_KEYBOARD_NAVIGATION_SUPPORT; +%csconstvalue("1 << 6") DISABLE_STYLE_CHANGE_SIGNALS; typedef unsigned int ItemId; typedef std::vector ItemIdContainer; diff --git a/plugins/dali-swig/SWIG/dali.i b/plugins/dali-swig/SWIG/dali.i index 7002568..3659b21 100755 --- a/plugins/dali-swig/SWIG/dali.i +++ b/plugins/dali-swig/SWIG/dali.i @@ -64,6 +64,7 @@ #include #include + #include #include #include @@ -172,10 +173,7 @@ using namespace Dali; using namespace Dali::Toolkit; %} -//%feature("director") Dali::Internal::CustomActorImpl; -//%feature("notabstract") Dali::Internal::CustomActorImpl; -//%feature("director") Dali::Toolkit::Internal::Control; -//%feature("notabstract") Dali::Toolkit::Internal::Control; +%feature("director") Dali::Toolkit::Internal::Control; %feature("notabstract") Dali::Toolkit::FixedRuler; %feature("notabstract") Dali::Toolkit::DefaultRuler; diff --git a/plugins/dali-swig/examples/custom-control.cs b/plugins/dali-swig/examples/custom-control.cs new file mode 100644 index 0000000..9dde85e --- /dev/null +++ b/plugins/dali-swig/examples/custom-control.cs @@ -0,0 +1,236 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +using System; +using System.Runtime.InteropServices; +using Dali; + +namespace MyCSharpExample +{ + // A custom control for star rating (draggable to change the rating) + class StarRating : CustomView + { + private FlexContainer _container; + private ImageView[] _images; + private Vector3 _gestureDisplacement; + private int _currentValue; + private int _myRating; + private bool _myDragEnabled; + + public StarRating() : base(ViewWrapperImpl.CustomViewBehaviour.VIEW_BEHAVIOUR_DEFAULT) + { + } + + public override void OnInitialize() + { + // Create a container for the star images + _container = new FlexContainer(); + + _container.ParentOrigin = NDalic.ParentOriginTopLeft; + _container.AnchorPoint = NDalic.AnchorPointTopLeft; + _container.FlexDirection = (int)FlexContainer.FlexDirectionType.ROW; + _container.WidthResizePolicy = "FILL_TO_PARENT"; + _container.HeightResizePolicy = "FILL_TO_PARENT"; + + this.Add(_container); + + // Create the images + _images = new ImageView[5]; + + for(int i = 0; i < 5; i++) + { + _images[i] = new ImageView("./images/star-dim.png"); + _container.Add( _images[i] ); + } + + // Update the images according to the rating (dimmed star by default) + _myRating = 0; + UpdateStartImages(_myRating); + + // Enable pan gesture detection + EnableGestureDetection(Gesture.Type.Pan); + _myDragEnabled = true; // Allow dragging by default (can be disabled) + } + + // Pan gesture handling + public override void OnPan(PanGesture gesture) + { + // Only handle pan gesture if dragging is allowed + if(_myDragEnabled) + { + switch (gesture.state) + { + case Gesture.State.Started: + { + _gestureDisplacement = new Vector3(0.0f, 0.0f, 0.0f); + _currentValue = 0; + break; + } + case Gesture.State.Continuing: + { + // Calculate the rating according to pan desture displacement + _gestureDisplacement.x += gesture.displacement.x; + int delta = (int)Math.Ceiling(_gestureDisplacement.x / 40.0f); + _currentValue = _myRating + delta; + + // Clamp the rating + if(_currentValue < 0) _currentValue = 0; + if(_currentValue > 5) _currentValue = 5; + + // Update the images according to the rating + UpdateStartImages(_currentValue); + break; + } + default: + { + _myRating = _currentValue; + break; + } + } + } + } + + // Update the images according to the rating + private void UpdateStartImages(int rating) + { + for(int i = 0; i < rating; i++) + { + _images[i].WidthResizePolicy = "USE_NATURAL_SIZE"; + _images[i].HeightResizePolicy = "USE_NATURAL_SIZE"; + _images[i].SetImage("./images/star-highlight.png"); + } + + for(int i = rating; i < 5; i++) + { + _images[i].WidthResizePolicy = "USE_NATURAL_SIZE"; + _images[i].HeightResizePolicy = "USE_NATURAL_SIZE"; + _images[i].SetImage("./images/star-dim.png"); + } + } + + // Rating property of type int: + public int Rating + { + get + { + return _myRating; + } + set + { + _myRating = value; + UpdateStartImages(_myRating); + } + } + + // DragEnabled property of type bool: + public bool DragEnabled + { + get + { + return _myDragEnabled; + } + set + { + _myDragEnabled = value; + } + } + } + + class Example + { + private Dali.Application _application; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + delegate void CallbackDelegate(); + + public Example(Dali.Application application) + { + _application = application; + _application.Initialized += Initialize; + } + + public void Initialize(object source, AUIApplicationInitEventArgs e) + { + Stage stage = Stage.GetCurrent(); + stage.SetBackgroundColor( NDalic.WHITE ); + + // Create a container to layout the rows of image and rating vertically + FlexContainer container = new FlexContainer(); + + container.ParentOrigin = NDalic.ParentOriginTopLeft; + container.AnchorPoint = NDalic.AnchorPointTopLeft; + container.FlexDirection = (int)FlexContainer.FlexDirectionType.COLUMN; + container.WidthResizePolicy = "FILL_TO_PARENT"; + container.HeightResizePolicy = "FILL_TO_PARENT"; + + stage.Add(container); + + Random random = new Random(); + + for(int i = 0; i < 6; i++) // 6 rows in total + { + // Create a container to layout the image and rating (in each row) horizontally + FlexContainer imageRow = new FlexContainer(); + imageRow.ParentOrigin = NDalic.ParentOriginTopLeft; + imageRow.AnchorPoint = NDalic.AnchorPointTopLeft; + imageRow.FlexDirection = (int)FlexContainer.FlexDirectionType.ROW; + imageRow.Flex = 1.0f; + container.Add(imageRow); + + // Add the image view to the row + ImageView image = new ImageView("./images/gallery-" + i + ".jpg"); + image.Size = new Vector3(120.0f, 120.0f, 0.0f); + image.WidthResizePolicy = "FIXED"; + image.HeightResizePolicy = "FIXED"; + image.AlignSelf = (int)FlexContainer.Alignment.ALIGN_CENTER; + image.Flex = 0.3f; + image.FlexMargin = new Vector4(10.0f, 0.0f, 0.0f, 0.0f); + imageRow.Add(image); + + // Create a rating control + StarRating view = new StarRating(); + + // Add the rating control to the row + view.ParentOrigin = NDalic.ParentOriginCenter; + view.AnchorPoint = NDalic.AnchorPointCenter; + view.Size = new Vector3(200.0f, 40.0f, 0.0f); + view.Flex = 0.7f; + view.AlignSelf = (int)FlexContainer.Alignment.ALIGN_CENTER; + view.FlexMargin = new Vector4(30.0f, 0.0f, 0.0f, 0.0f); + imageRow.Add(view); + + // Set the initial rating randomly between 1 and 5 + view.Rating = random.Next(1, 6); + } + } + + public void MainLoop() + { + _application.MainLoop (); + } + + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main(string[] args) + { + Example example = new Example(Application.NewApplication()); + example.MainLoop (); + } + } +} diff --git a/plugins/dali-swig/examples/images/arrow.png b/plugins/dali-swig/examples/images/arrow.png new file mode 100644 index 0000000..87abefd Binary files /dev/null and b/plugins/dali-swig/examples/images/arrow.png differ diff --git a/plugins/dali-swig/examples/spin-control.cs b/plugins/dali-swig/examples/spin-control.cs new file mode 100644 index 0000000..15b0d8b --- /dev/null +++ b/plugins/dali-swig/examples/spin-control.cs @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +using System; +using System.Runtime.InteropServices; +using Dali; + +namespace MyCSharpExample +{ + // A spin control (for continously changing values when users can easily predict a set of values) + class Spin : CustomView + { + private VisualBase _arrowVisual; + private TextField _textField; + private int _arrowVisualPropertyIndex; + private string _arrowImage; + private int _currentValue; + private int _minValue; + private int _maxValue; + private int _singleStep; + private bool _wrappingEnabled; + private string _fontFamily; + private string _fontStyle; + private int _pointSize; + private Vector4 _textColor; + private Vector4 _textBackgroundColor; + private int _maxTextLength; + + public Spin() : base(ViewWrapperImpl.CustomViewBehaviour.REQUIRES_KEYBOARD_NAVIGATION_SUPPORT | ViewWrapperImpl.CustomViewBehaviour.DISABLE_STYLE_CHANGE_SIGNALS) + { + } + + public override void OnInitialize() + { + // Initialize the properties + _arrowImage = "./images/arrow.png"; + _textBackgroundColor = new Vector4(0.6f, 0.6f, 0.6f, 1.0f); + _currentValue = 0; + _minValue = 0; + _maxValue = 0; + _singleStep = 1; + _maxTextLength = 0; + + // Create image visual for the arrow keys + _arrowVisualPropertyIndex = RegisterProperty("ArrowImage", new Dali.Property.Value(_arrowImage), Dali.Property.AccessMode.READ_WRITE); + _arrowVisual = VisualFactory.Get().CreateVisual( _arrowImage, new Uint16Pair(150, 150) ); + RegisterVisual( _arrowVisualPropertyIndex, _arrowVisual ); + + // Create a text field + _textField = new TextField(); + _textField.ParentOrigin = NDalic.ParentOriginCenter; + _textField.AnchorPoint = NDalic.AnchorPointCenter; + _textField.WidthResizePolicy = "SIZE_RELATIVE_TO_PARENT"; + _textField.HeightResizePolicy = "SIZE_RELATIVE_TO_PARENT"; + _textField.SizeModeFactor = new Vector3( 1.0f, 0.45f, 1.0f ); + _textField.PlaceholderText = "----"; + _textField.BackgroundColor = _textBackgroundColor; + _textField.HorizontalAlignment = "Center"; + _textField.VerticalAlignment = "Center"; + _textField.SetKeyboardFocusable(true); + _textField.Name = "_textField"; + + this.Add(_textField); + + _textField.KeyInputFocusGained += TextFieldKeyInputFocusGained; + _textField.KeyInputFocusLost += TextFieldKeyInputFocusLost; + } + + public override Vector3 GetNaturalSize() + { + return new Vector3(150.0f, 150.0f, 0.0f); + } + + public void TextFieldKeyInputFocusGained(object source, KeyInputFocusGainedEventArgs e) + { + // Make sure when the current spin that takes input focus also takes the keyboard focus + // For example, when you tap the spin directly + KeyboardFocusManager.Get().SetCurrentFocusActor(_textField); + } + + public void TextFieldKeyInputFocusLost(object source, KeyInputFocusLostEventArgs e) + { + int previousValue = _currentValue; + + // If the input value is invalid, change it back to the previous valid value + if(int.TryParse(_textField.Text, out _currentValue)) + { + if (_currentValue < _minValue || _currentValue > _maxValue) + { + _currentValue = previousValue; + } + } + else + { + _currentValue = previousValue; + } + + // Otherwise take the new value + this.Value = _currentValue; + } + + public override Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, View.KeyboardFocus.Direction direction, bool loopEnabled) + { + // Respond to Up/Down keys to change the value while keeping the current spin focused + Actor nextFocusedActor = currentFocusedActor; + if (direction == View.KeyboardFocus.Direction.UP) + { + this.Value += this.Step; + nextFocusedActor = _textField; + } + else if (direction == View.KeyboardFocus.Direction.DOWN) + { + this.Value -= this.Step; + nextFocusedActor = _textField; + } + else + { + // Return a native empty handle as nothing can be focused in the left or right + nextFocusedActor = new Actor(); + nextFocusedActor.Reset(); + } + + return nextFocusedActor; + } + + // Value property of type int: + public int Value + { + get + { + return _currentValue; + } + set + { + _currentValue = value; + + // Make sure no invalid value is accepted + if (_currentValue < _minValue) + { + _currentValue = _minValue; + } + + if (_currentValue > _maxValue) + { + _currentValue = _maxValue; + } + + _textField.Text = _currentValue.ToString(); + } + } + + // MinValue property of type int: + public int MinValue + { + get + { + return _minValue; + } + set + { + _minValue = value; + } + } + + // MaxValue property of type int: + public int MaxValue + { + get + { + return _maxValue; + } + set + { + _maxValue = value; + } + } + + // Step property of type int: + public int Step + { + get + { + return _singleStep; + } + set + { + _singleStep = value; + } + } + + // WrappingEnabled property of type bool: + public bool WrappingEnabled + { + get + { + return _wrappingEnabled; + } + set + { + _wrappingEnabled = value; + } + } + + // TextPointSize property of type int: + public int TextPointSize + { + get + { + return _pointSize; + } + set + { + _pointSize = value; + _textField.PointSize = _pointSize; + } + } + + // TextColor property of type Vector4: + public Vector4 TextColor + { + get + { + return _textColor; + } + set + { + _textColor = value; + _textField.TextColor = _textColor; + } + } + + // MaxTextLength property of type int: + public int MaxTextLength + { + get + { + return _maxTextLength; + } + set + { + _maxTextLength = value; + _textField.MaxLength = _maxTextLength; + } + } + + public TextField SpinText + { + get + { + return _textField; + } + set + { + _textField = value; + } + } + + // Indicator property of type string: + public string IndicatorImage + { + get + { + return _arrowImage; + } + set + { + _arrowImage = value; + _arrowVisual = VisualFactory.Get().CreateVisual( _arrowImage, new Uint16Pair(150, 150) ); + RegisterVisual( _arrowVisualPropertyIndex, _arrowVisual ); + } + } + } + + class Example + { + private Dali.Application _application; + private FlexContainer _container; + private Spin _spinYear; + private Spin _spinMonth; + private Spin _spinDay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + delegate void CallbackDelegate(); + + public Example(Dali.Application application) + { + _application = application; + _application.Initialized += Initialize; + } + + public void Initialize(object source, AUIApplicationInitEventArgs e) + { + Stage stage = Stage.GetCurrent(); + stage.SetBackgroundColor( NDalic.WHITE ); + + // Create a container for the spins + _container = new FlexContainer(); + + _container.ParentOrigin = NDalic.ParentOriginCenter; + _container.AnchorPoint = NDalic.AnchorPointCenter; + _container.FlexDirection = (int)FlexContainer.FlexDirectionType.ROW; + _container.Size = new Vector3(480.0f, 150.0f, 0.0f); + + stage.Add(_container); + + // Create a Spin control for year + _spinYear = new Spin(); + _spinYear.ParentOrigin = NDalic.ParentOriginCenter; + _spinYear.AnchorPoint = NDalic.AnchorPointCenter; + _spinYear.Flex = 0.3f; + _spinYear.FlexMargin = new Vector4(5.0f, 0.0f, 5.0f, 0.0f); + _container.Add(_spinYear); + + _spinYear.MinValue = 1900; + _spinYear.MaxValue = 2100; + _spinYear.Value = 2016; + _spinYear.Step = 1; + _spinYear.MaxTextLength = 4; + _spinYear.TextPointSize = 26; + _spinYear.TextColor = NDalic.WHITE; + _spinYear.SetKeyboardFocusable(true); + _spinYear.Name = "_spinYear"; + + // Create a Spin control for month + _spinMonth = new Spin(); + _spinMonth.ParentOrigin = NDalic.ParentOriginCenter; + _spinMonth.AnchorPoint = NDalic.AnchorPointCenter; + _spinMonth.Flex = 0.3f; + _spinMonth.FlexMargin = new Vector4(5.0f, 0.0f, 5.0f, 0.0f); + _container.Add(_spinMonth); + + _spinMonth.MinValue = 1; + _spinMonth.MaxValue = 12; + _spinMonth.Value = 10; + _spinMonth.Step = 1; + _spinMonth.MaxTextLength = 2; + _spinMonth.TextPointSize = 26; + _spinMonth.TextColor = NDalic.WHITE; + _spinMonth.SetKeyboardFocusable(true); + _spinMonth.Name = "_spinMonth"; + + // Create a Spin control for day + _spinDay = new Spin(); + _spinDay.ParentOrigin = NDalic.ParentOriginCenter; + _spinDay.AnchorPoint = NDalic.AnchorPointCenter; + _spinDay.Flex = 0.3f; + _spinDay.FlexMargin = new Vector4(5.0f, 0.0f, 5.0f, 0.0f); + _container.Add(_spinDay); + + _spinDay.MinValue = 1; + _spinDay.MaxValue = 31; + _spinDay.Value = 26; + _spinDay.Step = 1; + _spinDay.MaxTextLength = 2; + _spinDay.TextPointSize = 26; + _spinDay.TextColor = NDalic.WHITE; + _spinDay.SetKeyboardFocusable(true); + _spinDay.Name = "_spinDay"; + + KeyboardFocusManager keyboardFocusManager = KeyboardFocusManager.Get(); + keyboardFocusManager.PreFocusChange += OnKeyboardPreFocusChange; + keyboardFocusManager.FocusedActorEnterKeyPressed += OnFocusedActorEnterKeyPressed; + + } + + private Actor OnKeyboardPreFocusChange(object source, KeyboardFocusManager.PreFocusChangeEventArgs e) + { + Actor nextFocusActor = e.Proposed; + + // When nothing has been focused initially, focus the text field in the first spin + if (!e.Current && !e.Proposed) + { + nextFocusActor = _spinYear.SpinText; + } + else if(e.Direction == View.KeyboardFocus.Direction.LEFT) + { + // Move the focus to the spin in the left of the current focused spin + if(e.Current == _spinMonth.SpinText) + { + nextFocusActor = _spinYear.SpinText; + } + else if(e.Current == _spinDay.SpinText) + { + nextFocusActor = _spinMonth.SpinText; + } + } + else if(e.Direction == View.KeyboardFocus.Direction.RIGHT) + { + // Move the focus to the spin in the right of the current focused spin + if(e.Current == _spinYear.SpinText) + { + nextFocusActor = _spinMonth.SpinText; + } + else if(e.Current == _spinMonth.SpinText) + { + nextFocusActor = _spinDay.SpinText; + } + } + + return nextFocusActor; + } + + private void OnFocusedActorEnterKeyPressed(object source, KeyboardFocusManager.FocusedActorEnterKeyEventArgs e) + { + // Make the text field in the current focused spin to take the key input + KeyInputFocusManager manager = KeyInputFocusManager.Get(); + + if (e.Actor == _spinYear.SpinText) + { + if (manager.GetCurrentFocusControl() != _spinYear.SpinText) + { + manager.SetFocus(_spinYear.SpinText); + } + } + else if (e.Actor == _spinMonth.SpinText) + { + if (manager.GetCurrentFocusControl() != _spinMonth.SpinText) + { + manager.SetFocus(_spinMonth.SpinText); + } + } + else if (e.Actor == _spinDay.SpinText) + { + if (manager.GetCurrentFocusControl() != _spinDay.SpinText) + { + manager.SetFocus(_spinDay.SpinText); + } + } + } + + public void MainLoop() + { + _application.MainLoop (); + } + + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main(string[] args) + { + Example example = new Example(Application.NewApplication()); + example.MainLoop (); + } + } +} diff --git a/plugins/dali-swig/manual/cpp/common.h b/plugins/dali-swig/manual/cpp/common.h index 7011fc2..9f8d237 100644 --- a/plugins/dali-swig/manual/cpp/common.h +++ b/plugins/dali-swig/manual/cpp/common.h @@ -1,9 +1,51 @@ -#ifndef CSHARP_COMMON -#define CSHARP_COMMON -#endif +#ifndef CSHARP_COMMON_H +#define CSHARP_COMMON_H + +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ #define SWIG_DIRECTORS +#ifdef __cplusplus +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper +{ + struct SwigMovePointer + { + T *ptr; + SwigMovePointer(T *p) : ptr(p) { } + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } + operator T&() const { return *pointer.ptr; } + T *operator&() { return pointer.ptr; } +}; + +template T SwigValueInit() +{ + return T(); +} +#endif + #include #define SWIGSTDCALL @@ -65,7 +107,8 @@ /* 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 { +typedef enum +{ SWIG_CSharpApplicationException, SWIG_CSharpArithmeticException, SWIG_CSharpDivideByZeroException, @@ -79,7 +122,8 @@ typedef enum { SWIG_CSharpSystemException } SWIG_CSharpExceptionCodes; -typedef enum { +typedef enum +{ SWIG_CSharpArgumentException, SWIG_CSharpArgumentNullException, SWIG_CSharpArgumentOutOfRangeException @@ -88,17 +132,20 @@ typedef enum { typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *); typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *); -typedef struct { +typedef struct +{ SWIG_CSharpExceptionCodes code; SWIG_CSharpExceptionCallback_t callback; } SWIG_CSharpException_t; -typedef struct { +typedef struct +{ SWIG_CSharpExceptionArgumentCodes code; SWIG_CSharpExceptionArgumentCallback_t callback; } SWIG_CSharpExceptionArgument_t; -static SWIG_CSharpException_t SWIG_csharp_exceptions[] = { +static SWIG_CSharpException_t SWIG_csharp_exceptions[] = +{ { SWIG_CSharpApplicationException, NULL }, { SWIG_CSharpArithmeticException, NULL }, { SWIG_CSharpDivideByZeroException, NULL }, @@ -112,15 +159,18 @@ static SWIG_CSharpException_t SWIG_csharp_exceptions[] = { { SWIG_CSharpSystemException, NULL } }; -static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = { +static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = +{ { SWIG_CSharpArgumentException, NULL }, { SWIG_CSharpArgumentNullException, NULL }, { SWIG_CSharpArgumentOutOfRangeException, NULL } }; -static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) { +static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) +{ SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback; - if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) { + if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) + { callback = SWIG_csharp_exceptions[code].callback; } callback(msg); @@ -134,52 +184,54 @@ static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExcepti callback(msg, param_name); } -SWIGINTERN void SWIG_CSharpException(int code, const char *msg) { - if (code == SWIG_ValueError) { +SWIGINTERN void SWIG_CSharpException(int code, const char *msg) +{ + if (code == SWIG_ValueError) + { SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException; SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0); - } else { + } + else + { SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException; - switch(code) { - case SWIG_MemoryError: - exception_code = SWIG_CSharpOutOfMemoryException; - break; - case SWIG_IndexError: - exception_code = SWIG_CSharpIndexOutOfRangeException; - break; - case SWIG_DivisionByZero: - exception_code = SWIG_CSharpDivideByZeroException; - break; - case SWIG_IOError: - exception_code = SWIG_CSharpIOException; - break; - case SWIG_OverflowError: - exception_code = SWIG_CSharpOverflowException; - break; - case SWIG_RuntimeError: - case SWIG_TypeError: - case SWIG_SyntaxError: - case SWIG_SystemError: - case SWIG_UnknownError: - default: - exception_code = SWIG_CSharpApplicationException; - break; + switch(code) + { + case SWIG_MemoryError: + exception_code = SWIG_CSharpOutOfMemoryException; + break; + case SWIG_IndexError: + exception_code = SWIG_CSharpIndexOutOfRangeException; + break; + case SWIG_DivisionByZero: + exception_code = SWIG_CSharpDivideByZeroException; + break; + case SWIG_IOError: + exception_code = SWIG_CSharpIOException; + break; + case SWIG_OverflowError: + exception_code = SWIG_CSharpOverflowException; + break; + case SWIG_RuntimeError: + case SWIG_TypeError: + case SWIG_SyntaxError: + case SWIG_SystemError: + case SWIG_UnknownError: + default: + exception_code = SWIG_CSharpApplicationException; + break; } SWIG_CSharpSetPendingException(exception_code, msg); } } - #include - #define SWIGSTDCALL - #include #include -using namespace Dali; -using namespace Dali::Toolkit; - +#include +#include +#endif // CSHARP_COMMON_H diff --git a/plugins/dali-swig/manual/cpp/keyboard_focus_manager_wrap.cpp b/plugins/dali-swig/manual/cpp/keyboard_focus_manager_wrap.cpp index d2a017c..5651b9e 100644 --- a/plugins/dali-swig/manual/cpp/keyboard_focus_manager_wrap.cpp +++ b/plugins/dali-swig/manual/cpp/keyboard_focus_manager_wrap.cpp @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + #ifndef CSHARP_KEYBOARD_FOCUS_MANAGER #define CSHARP_KEYBOARD_FOCUS_MANAGER #endif diff --git a/plugins/dali-swig/manual/cpp/view-wrapper-impl-wrap.cpp b/plugins/dali-swig/manual/cpp/view-wrapper-impl-wrap.cpp new file mode 100644 index 0000000..3354408 --- /dev/null +++ b/plugins/dali-swig/manual/cpp/view-wrapper-impl-wrap.cpp @@ -0,0 +1,1378 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// CLASS HEADER +#include "view-wrapper-impl-wrap.h" + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SwigDirector_ViewWrapperImpl::SwigDirector_ViewWrapperImpl(Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::ControlWrapper(behaviourFlags) { + swig_init_callbacks(); +} + +SwigDirector_ViewWrapperImpl::~SwigDirector_ViewWrapperImpl() { + +} + + +void SwigDirector_ViewWrapperImpl::OnStageConnection(int depth) { + Dali::Toolkit::Internal::Control::OnStageConnection(depth); + swig_callbackOnStageConnection(depth); +} + +void SwigDirector_ViewWrapperImpl::OnStageDisconnection() { + swig_callbackOnStageDisconnection(); + Dali::Toolkit::Internal::Control::OnStageDisconnection(); +} + +void SwigDirector_ViewWrapperImpl::OnChildAdd(Dali::Actor &child) { + Dali::Toolkit::Internal::Control::OnChildAdd( child ); + void * jchild = (Dali::Actor *) &child; + swig_callbackOnChildAdd(jchild); +} + +void SwigDirector_ViewWrapperImpl::OnChildRemove(Dali::Actor &child) { + void * jchild = (Dali::Actor *) &child; + swig_callbackOnChildRemove(jchild); + Dali::Toolkit::Internal::Control::OnChildRemove( child ); +} + +void SwigDirector_ViewWrapperImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) { + int jindex ; + void * jpropertyValue ; + + if (!swig_callbackOnPropertySet) { + Dali::Toolkit::Internal::ControlWrapper::OnPropertySet(index,propertyValue); + return; + } else { + jindex = index; + jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue); + swig_callbackOnPropertySet(jindex, jpropertyValue); + } +} + +void SwigDirector_ViewWrapperImpl::OnSizeSet(Dali::Vector3 const &targetSize) { + Dali::Toolkit::Internal::Control::OnSizeSet(targetSize); + swig_callbackOnSizeSet((Dali::Vector3 *) &targetSize); +} + +void SwigDirector_ViewWrapperImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) { + Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize); + swig_callbackOnSizeAnimation(&animation, (Dali::Vector3 *) &targetSize); +} + +bool SwigDirector_ViewWrapperImpl::OnTouchEvent(Dali::TouchEvent const &event) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + void * jarg0 = 0 ; + + if (!swig_callbackOnTouchEvent) { + return Dali::Toolkit::Internal::Control::OnTouchEvent(event); + } else { + jarg0 = (Dali::TouchEvent *) &event; + jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::OnHoverEvent(Dali::HoverEvent const &event) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + void * jarg0 = 0 ; + + if (!swig_callbackOnHoverEvent) { + return Dali::Toolkit::Internal::Control::OnHoverEvent(event); + } else { + jarg0 = (Dali::HoverEvent *) &event; + jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::OnKeyEvent(Dali::KeyEvent const &event) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + void * jarg0 = 0 ; + + if (!swig_callbackOnKeyEvent) { + return Dali::Toolkit::Internal::Control::OnKeyEvent(event); + } else { + jarg0 = (Dali::KeyEvent *) &event; + jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::OnWheelEvent(Dali::WheelEvent const &event) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + void * jarg0 = 0 ; + + if (!swig_callbackOnWheelEvent) { + return Dali::Toolkit::Internal::Control::OnWheelEvent(event); + } else { + jarg0 = (Dali::WheelEvent *) &event; + jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0); + c_result = jresult ? true : false; + } + return c_result; +} + +void SwigDirector_ViewWrapperImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) { + void * jsize = 0 ; + void * jcontainer = 0 ; + + if (!swig_callbackOnRelayout) { + Dali::Toolkit::Internal::Control::OnRelayout(size,container); + return; + } else { + jsize = (Dali::Vector2 *) &size; + jcontainer = (Dali::RelayoutContainer *) &container; + swig_callbackOnRelayout(jsize, jcontainer); + } +} + +void SwigDirector_ViewWrapperImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) { + int jpolicy ; + int jdimension ; + + if (!swig_callbackOnSetResizePolicy) { + Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension); + return; + } else { + jpolicy = (int)policy; + jdimension = (int)dimension; + swig_callbackOnSetResizePolicy(jpolicy, jdimension); + } +} + +Dali::Vector3 SwigDirector_ViewWrapperImpl::GetNaturalSize() { + Dali::Vector3 c_result ; + void * jresult = 0 ; + + if (!swig_callbackGetNaturalSize) { + return Dali::Toolkit::Internal::Control::GetNaturalSize(); + } else { + jresult = (void *) swig_callbackGetNaturalSize(); + if (!jresult) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0); + return c_result; + } + c_result = *(Dali::Vector3 *)jresult; + } + return c_result; +} + +float SwigDirector_ViewWrapperImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) { + float c_result = SwigValueInit< float >() ; + float jresult = 0 ; + void * jchild = 0 ; + int jdimension ; + + if (!swig_callbackCalculateChildSize) { + return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension); + } else { + jchild = (Dali::Actor *) &child; + jdimension = (int)dimension; + jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension); + c_result = (float)jresult; + } + return c_result; +} + +float SwigDirector_ViewWrapperImpl::GetHeightForWidth(float width) { + float c_result = SwigValueInit< float >() ; + float jresult = 0 ; + float jwidth ; + + if (!swig_callbackGetHeightForWidth) { + return Dali::Toolkit::Internal::Control::GetHeightForWidth(width); + } else { + jwidth = width; + jresult = (float) swig_callbackGetHeightForWidth(jwidth); + c_result = (float)jresult; + } + return c_result; +} + +float SwigDirector_ViewWrapperImpl::GetWidthForHeight(float height) { + float c_result = SwigValueInit< float >() ; + float jresult = 0 ; + float jheight ; + + if (!swig_callbackGetWidthForHeight) { + return Dali::Toolkit::Internal::Control::GetWidthForHeight(height); + } else { + jheight = height; + jresult = (float) swig_callbackGetWidthForHeight(jheight); + c_result = (float)jresult; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + int jdimension ; + + if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) { + return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension); + } else { + jdimension = (int)dimension; + jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension); + c_result = jresult ? true : false; + } + return c_result; +} + +void SwigDirector_ViewWrapperImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) { + int jdimension ; + + if (!swig_callbackOnCalculateRelayoutSize) { + Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension); + return; + } else { + jdimension = (int)dimension; + swig_callbackOnCalculateRelayoutSize(jdimension); + } +} + +void SwigDirector_ViewWrapperImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) { + float jsize ; + int jdimension ; + + if (!swig_callbackOnLayoutNegotiated) { + Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension); + return; + } else { + jsize = size; + jdimension = (int)dimension; + swig_callbackOnLayoutNegotiated(jsize, jdimension); + } +} + +void SwigDirector_ViewWrapperImpl::OnInitialize() { + if (!swig_callbackOnInitialize) { + Dali::Toolkit::Internal::Control::OnInitialize(); + return; + } else { + swig_callbackOnInitialize(); + } +} + +void SwigDirector_ViewWrapperImpl::OnControlChildAdd(Dali::Actor &child) { + Dali::Toolkit::Internal::Control::OnControlChildAdd(child); + swig_callbackOnControlChildAdd(&child); +} + +void SwigDirector_ViewWrapperImpl::OnControlChildRemove(Dali::Actor &child) { + swig_callbackOnControlChildRemove(&child); + Dali::Toolkit::Internal::Control::OnControlChildRemove(child); +} + +void SwigDirector_ViewWrapperImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) { + void * jstyleManager ; + int jchange ; + + if (!swig_callbackOnStyleChange) { + Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change); + return; + } else { + jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager); + jchange = (int)change; + swig_callbackOnStyleChange(jstyleManager, jchange); + } +} + +bool SwigDirector_ViewWrapperImpl::OnAccessibilityActivated() { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + + if (!swig_callbackOnAccessibilityActivated) { + return Dali::Toolkit::Internal::Control::OnAccessibilityActivated(); + } else { + jresult = (unsigned int) swig_callbackOnAccessibilityActivated(); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::OnAccessibilityPan(Dali::PanGesture gesture) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + void * jgesture ; + + if (!swig_callbackOnAccessibilityPan) { + return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture); + } else { + jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture); + jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + void * jtouchEvent = 0 ; + + if (!swig_callbackOnAccessibilityTouch) { + return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent); + } else { + jtouchEvent = (Dali::TouchEvent *) &touchEvent; + jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::OnAccessibilityValueChange(bool isIncrease) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + unsigned int jisIncrease ; + + if (!swig_callbackOnAccessibilityValueChange) { + return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease); + } else { + jisIncrease = isIncrease; + jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::OnAccessibilityZoom() { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + + if (!swig_callbackOnAccessibilityZoom) { + return Dali::Toolkit::Internal::Control::OnAccessibilityZoom(); + } else { + jresult = (unsigned int) swig_callbackOnAccessibilityZoom(); + c_result = jresult ? true : false; + } + return c_result; +} + +void SwigDirector_ViewWrapperImpl::OnKeyInputFocusGained() { + if (!swig_callbackOnKeyInputFocusGained) { + Dali::Toolkit::Internal::Control::OnKeyInputFocusGained(); + return; + } else { + swig_callbackOnKeyInputFocusGained(); + } +} + +void SwigDirector_ViewWrapperImpl::OnKeyInputFocusLost() { + if (!swig_callbackOnKeyInputFocusLost) { + Dali::Toolkit::Internal::Control::OnKeyInputFocusLost(); + return; + } else { + swig_callbackOnKeyInputFocusLost(); + } +} + +Dali::Actor SwigDirector_ViewWrapperImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) { + Dali::Actor c_result ; + void * jresult = 0 ; + void * jcurrentFocusedActor ; + int jdirection ; + unsigned int jloopEnabled ; + + if (!swig_callbackGetNextKeyboardFocusableActor) { + return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled); + } else { + jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor); + jdirection = (int)direction; + jloopEnabled = loopEnabled; + jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled); + if (!jresult) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0); + return c_result; + } + c_result = *(Dali::Actor *)jresult; + } + return c_result; +} + +void SwigDirector_ViewWrapperImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) { + void * jcommitedFocusableActor ; + + if (!swig_callbackOnKeyboardFocusChangeCommitted) { + Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor); + return; + } else { + jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor); + swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor); + } +} + +bool SwigDirector_ViewWrapperImpl::OnKeyboardEnter() { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + + if (!swig_callbackOnKeyboardEnter) { + return Dali::Toolkit::Internal::Control::OnKeyboardEnter(); + } else { + jresult = (unsigned int) swig_callbackOnKeyboardEnter(); + c_result = jresult ? true : false; + } + return c_result; +} + +void SwigDirector_ViewWrapperImpl::OnPinch(Dali::PinchGesture const &pinch) { + void * jpinch = 0 ; + + if (!swig_callbackOnPinch) { + Dali::Toolkit::Internal::Control::OnPinch(pinch); + return; + } else { + jpinch = (Dali::PinchGesture *) &pinch; + swig_callbackOnPinch(jpinch); + } +} + +void SwigDirector_ViewWrapperImpl::OnPan(Dali::PanGesture const &pan) { + void * jpan = 0 ; + + if (!swig_callbackOnPan) { + Dali::Toolkit::Internal::Control::OnPan(pan); + return; + } else { + jpan = (Dali::PanGesture *) &pan; + swig_callbackOnPan(jpan); + } +} + +void SwigDirector_ViewWrapperImpl::OnTap(Dali::TapGesture const &tap) { + void * jtap = 0 ; + + if (!swig_callbackOnTap) { + Dali::Toolkit::Internal::Control::OnTap(tap); + return; + } else { + jtap = (Dali::TapGesture *) &tap; + swig_callbackOnTap(jtap); + } +} + +void SwigDirector_ViewWrapperImpl::OnLongPress(Dali::LongPressGesture const &longPress) { + void * jlongPress = 0 ; + + if (!swig_callbackOnLongPress) { + Dali::Toolkit::Internal::Control::OnLongPress(longPress); + return; + } else { + jlongPress = (Dali::LongPressGesture *) &longPress; + swig_callbackOnLongPress(jlongPress); + } +} + +void SwigDirector_ViewWrapperImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) { + void * jslotObserver = 0 ; + void * jcallback = 0 ; + + if (!swig_callbackSignalConnected) { + Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback); + return; + } else { + jslotObserver = (void *) slotObserver; + jcallback = (void *) callback; + swig_callbackSignalConnected(jslotObserver, jcallback); + } +} + +void SwigDirector_ViewWrapperImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) { + void * jslotObserver = 0 ; + void * jcallback = 0 ; + + if (!swig_callbackSignalDisconnected) { + Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback); + return; + } else { + jslotObserver = (void *) slotObserver; + jcallback = (void *) callback; + swig_callbackSignalDisconnected(jslotObserver, jcallback); + } +} + +Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewWrapperImpl::GetControlExtension() { + return Dali::Toolkit::Internal::Control::GetControlExtension(); +} + +void SwigDirector_ViewWrapperImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) { + swig_callbackOnStageConnection = callbackOnStageConnection; + swig_callbackOnStageDisconnection = callbackOnStageDisconnection; + swig_callbackOnChildAdd = callbackOnChildAdd; + swig_callbackOnChildRemove = callbackOnChildRemove; + swig_callbackOnPropertySet = callbackOnPropertySet; + swig_callbackOnSizeSet = callbackOnSizeSet; + swig_callbackOnSizeAnimation = callbackOnSizeAnimation; + swig_callbackOnTouchEvent = callbackOnTouchEvent; + swig_callbackOnHoverEvent = callbackOnHoverEvent; + swig_callbackOnKeyEvent = callbackOnKeyEvent; + swig_callbackOnWheelEvent = callbackOnWheelEvent; + swig_callbackOnRelayout = callbackOnRelayout; + swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy; + swig_callbackGetNaturalSize = callbackGetNaturalSize; + swig_callbackCalculateChildSize = callbackCalculateChildSize; + swig_callbackGetHeightForWidth = callbackGetHeightForWidth; + swig_callbackGetWidthForHeight = callbackGetWidthForHeight; + swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0; + swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1; + swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize; + swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated; + swig_callbackOnInitialize = callbackOnInitialize; + swig_callbackOnControlChildAdd = callbackOnControlChildAdd; + swig_callbackOnControlChildRemove = callbackOnControlChildRemove; + swig_callbackOnStyleChange = callbackOnStyleChange; + swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated; + swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan; + swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch; + swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange; + swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom; + swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained; + swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost; + swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor; + swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted; + swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter; + swig_callbackOnPinch = callbackOnPinch; + swig_callbackOnPan = callbackOnPan; + swig_callbackOnTap = callbackOnTap; + swig_callbackOnLongPress = callbackOnLongPress; + swig_callbackSignalConnected = callbackSignalConnected; + swig_callbackSignalDisconnected = callbackSignalDisconnected; +} + +void SwigDirector_ViewWrapperImpl::swig_init_callbacks() { + swig_callbackOnStageConnection = 0; + swig_callbackOnStageDisconnection = 0; + swig_callbackOnChildAdd = 0; + swig_callbackOnChildRemove = 0; + swig_callbackOnPropertySet = 0; + swig_callbackOnSizeSet = 0; + swig_callbackOnSizeAnimation = 0; + swig_callbackOnTouchEvent = 0; + swig_callbackOnHoverEvent = 0; + swig_callbackOnKeyEvent = 0; + swig_callbackOnWheelEvent = 0; + swig_callbackOnRelayout = 0; + swig_callbackOnSetResizePolicy = 0; + swig_callbackGetNaturalSize = 0; + swig_callbackCalculateChildSize = 0; + swig_callbackGetHeightForWidth = 0; + swig_callbackGetWidthForHeight = 0; + swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0; + swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0; + swig_callbackOnCalculateRelayoutSize = 0; + swig_callbackOnLayoutNegotiated = 0; + swig_callbackOnInitialize = 0; + swig_callbackOnControlChildAdd = 0; + swig_callbackOnControlChildRemove = 0; + swig_callbackOnStyleChange = 0; + swig_callbackOnAccessibilityActivated = 0; + swig_callbackOnAccessibilityPan = 0; + swig_callbackOnAccessibilityTouch = 0; + swig_callbackOnAccessibilityValueChange = 0; + swig_callbackOnAccessibilityZoom = 0; + swig_callbackOnKeyInputFocusGained = 0; + swig_callbackOnKeyInputFocusLost = 0; + swig_callbackGetNextKeyboardFocusableActor = 0; + swig_callbackOnKeyboardFocusChangeCommitted = 0; + swig_callbackOnKeyboardEnter = 0; + swig_callbackOnPinch = 0; + swig_callbackOnPan = 0; + swig_callbackOnTap = 0; + swig_callbackOnLongPress = 0; + swig_callbackSignalConnected = 0; + swig_callbackSignalDisconnected = 0; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_CONTROL_BEHAVIOUR_FLAG_COUNT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_FLAG_COUNT; + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewWrapperImpl(int jarg1) { + void * jresult ; + Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour arg1 ; + Dali::Toolkit::Internal::ControlWrapper *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour)jarg1; + { + try { + result = (Dali::Toolkit::Internal::ControlWrapper *)new SwigDirector_ViewWrapperImpl(arg1); + } 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_ViewWrapperImpl_New(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Toolkit::ControlWrapper result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + { + try { + result = Dali::Toolkit::Internal::ControlWrapper::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::ControlWrapper((const Dali::Toolkit::ControlWrapper &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewWrapperImpl(void * jarg1) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + { + try { + if (arg1) + { + arg1->Unreference(); + } + } 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_ViewWrapperImpl_director_connect(void *objarg, SwigDirector_ViewWrapperImpl::SWIG_Callback0_t callback0, SwigDirector_ViewWrapperImpl::SWIG_Callback1_t callback1, SwigDirector_ViewWrapperImpl::SWIG_Callback2_t callback2, SwigDirector_ViewWrapperImpl::SWIG_Callback3_t callback3, SwigDirector_ViewWrapperImpl::SWIG_Callback4_t callback4, SwigDirector_ViewWrapperImpl::SWIG_Callback5_t callback5, SwigDirector_ViewWrapperImpl::SWIG_Callback6_t callback6, SwigDirector_ViewWrapperImpl::SWIG_Callback7_t callback7, SwigDirector_ViewWrapperImpl::SWIG_Callback8_t callback8, SwigDirector_ViewWrapperImpl::SWIG_Callback9_t callback9, SwigDirector_ViewWrapperImpl::SWIG_Callback10_t callback10, SwigDirector_ViewWrapperImpl::SWIG_Callback11_t callback11, SwigDirector_ViewWrapperImpl::SWIG_Callback12_t callback12, SwigDirector_ViewWrapperImpl::SWIG_Callback13_t callback13, SwigDirector_ViewWrapperImpl::SWIG_Callback14_t callback14, SwigDirector_ViewWrapperImpl::SWIG_Callback15_t callback15, SwigDirector_ViewWrapperImpl::SWIG_Callback16_t callback16, SwigDirector_ViewWrapperImpl::SWIG_Callback17_t callback17, SwigDirector_ViewWrapperImpl::SWIG_Callback18_t callback18, SwigDirector_ViewWrapperImpl::SWIG_Callback19_t callback19, SwigDirector_ViewWrapperImpl::SWIG_Callback20_t callback20, SwigDirector_ViewWrapperImpl::SWIG_Callback21_t callback21, SwigDirector_ViewWrapperImpl::SWIG_Callback22_t callback22, SwigDirector_ViewWrapperImpl::SWIG_Callback23_t callback23, SwigDirector_ViewWrapperImpl::SWIG_Callback24_t callback24, SwigDirector_ViewWrapperImpl::SWIG_Callback25_t callback25, SwigDirector_ViewWrapperImpl::SWIG_Callback26_t callback26, SwigDirector_ViewWrapperImpl::SWIG_Callback27_t callback27, SwigDirector_ViewWrapperImpl::SWIG_Callback28_t callback28, SwigDirector_ViewWrapperImpl::SWIG_Callback29_t callback29, SwigDirector_ViewWrapperImpl::SWIG_Callback30_t callback30, SwigDirector_ViewWrapperImpl::SWIG_Callback31_t callback31, SwigDirector_ViewWrapperImpl::SWIG_Callback32_t callback32, SwigDirector_ViewWrapperImpl::SWIG_Callback33_t callback33, SwigDirector_ViewWrapperImpl::SWIG_Callback34_t callback34, SwigDirector_ViewWrapperImpl::SWIG_Callback35_t callback35, SwigDirector_ViewWrapperImpl::SWIG_Callback36_t callback36, SwigDirector_ViewWrapperImpl::SWIG_Callback37_t callback37, SwigDirector_ViewWrapperImpl::SWIG_Callback38_t callback38, SwigDirector_ViewWrapperImpl::SWIG_Callback39_t callback39, SwigDirector_ViewWrapperImpl::SWIG_Callback40_t callback40) { + Dali::Toolkit::Internal::ControlWrapper *obj = (Dali::Toolkit::Internal::ControlWrapper *)objarg; + SwigDirector_ViewWrapperImpl *director = dynamic_cast(obj); + if (director) { + director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback22, callback23, callback24, callback25, callback26, callback27, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetControlWrapperImpl__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Toolkit::ControlWrapper *arg1 = 0 ; + Dali::Toolkit::Internal::ControlWrapper *result = 0 ; + + arg1 = (Dali::Toolkit::ControlWrapper *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ControlWrapper & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Internal::ControlWrapper *) &Dali::Toolkit::GetControlWrapperImpl(*arg1); + } 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_ViewWrapper_New(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = 0 ; + Dali::Toolkit::ControlWrapper result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::ControlWrapper & type is null", 0); + return 0; + } + { + try { + result = Dali::Toolkit::ControlWrapper::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::ControlWrapper((const Dali::Toolkit::ControlWrapper &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewWrapper__SWIG_0() { + void * jresult ; + Dali::Toolkit::ControlWrapper *result = 0 ; + + { + try { + result = (Dali::Toolkit::ControlWrapper *)new Dali::Toolkit::ControlWrapper(); + } 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_ViewWrapper(void * jarg1) { + Dali::Toolkit::ControlWrapper *arg1 = (Dali::Toolkit::ControlWrapper *) 0 ; + + arg1 = (Dali::Toolkit::ControlWrapper *)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_ViewWrapper__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::ControlWrapper *arg1 = 0 ; + Dali::Toolkit::ControlWrapper *result = 0 ; + + arg1 = (Dali::Toolkit::ControlWrapper *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ControlWrapper const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ControlWrapper *)new Dali::Toolkit::ControlWrapper((Dali::Toolkit::ControlWrapper const &)*arg1); + } 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_ViewWrapper_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::ControlWrapper *arg1 = (Dali::Toolkit::ControlWrapper *) 0 ; + Dali::Toolkit::ControlWrapper *arg2 = 0 ; + Dali::Toolkit::ControlWrapper *result = 0 ; + + arg1 = (Dali::Toolkit::ControlWrapper *)jarg1; + arg2 = (Dali::Toolkit::ControlWrapper *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ControlWrapper const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ControlWrapper *) &(arg1)->operator =((Dali::Toolkit::ControlWrapper const &)*arg2); + } 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_ViewWrapper_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::ControlWrapper result; + + argp1 = (Dali::BaseHandle *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = Dali::Toolkit::ControlWrapper::DownCast(arg1); + } 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::ControlWrapper((const Dali::Toolkit::ControlWrapper &)result); + return jresult; +} + +SWIGEXPORT Dali::Toolkit::Internal::Control * SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_SWIGUpcast(Dali::Toolkit::Internal::ControlWrapper *jarg1) { + return (Dali::Toolkit::Internal::Control *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ViewWrapper_SWIGUpcast(Dali::Toolkit::ControlWrapper *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_RelayoutRequest(void * jarg1) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + { + try { + (arg1)->RelayoutRequest(); + } 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 float SWIGSTDCALL CSharp_ViewWrapperImpl_GetHeightForWidthBase(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)(arg1)->GetHeightForWidthBase(arg2); + } 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 float SWIGSTDCALL CSharp_ViewWrapperImpl_GetWidthForHeightBase(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)(arg1)->GetWidthForHeightBase(arg2); + } 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 float SWIGSTDCALL CSharp_ViewWrapperImpl_CalculateChildSizeBase(void * jarg1, void * jarg2, int jarg3) { + float jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Actor *arg2 = 0 ; + Dali::Dimension::Type arg3 ; + float result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return 0; + } + arg3 = (Dali::Dimension::Type)jarg3; + { + try { + result = (float)(arg1)->CalculateChildSizeBase((Dali::Actor const &)*arg2,arg3); + } 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_ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_0(void * jarg1, int jarg2) { + unsigned int jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Dimension::Type arg2 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Dimension::Type)jarg2; + { + try { + result = (bool)(arg1)->RelayoutDependentOnChildrenBase(arg2); + } 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_ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_1(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + { + try { + result = (bool)(arg1)->RelayoutDependentOnChildrenBase(); + } 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_ViewWrapperImpl_RegisterVisual__SWIG_0(void * jarg1, int jarg2, void * jarg3) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + Dali::Toolkit::Visual::Base *arg3 = 0 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + arg3 = (Dali::Toolkit::Visual::Base *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base & type is null", 0); + return ; + } + { + try { + (arg1)->RegisterVisual(arg2,*arg3); + } 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_ViewWrapperImpl_RegisterVisual__SWIG_1(void * jarg1, int jarg2, void * jarg3, unsigned int jarg4) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + Dali::Toolkit::Visual::Base *arg3 = 0 ; + bool arg4 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + arg3 = (Dali::Toolkit::Visual::Base *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base & type is null", 0); + return ; + } + arg4 = jarg4 ? true : false; + { + try { + (arg1)->RegisterVisual(arg2,*arg3,arg4); + } 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_ViewWrapperImpl_UnregisterVisual(void * jarg1, int jarg2) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + (arg1)->UnregisterVisual(arg2); + } 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_ViewWrapperImpl_GetVisual(void * jarg1, int jarg2) { + void * jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + Dali::Toolkit::Visual::Base result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = ((Dali::Toolkit::Internal::ControlWrapper const *)arg1)->GetVisual(arg2); + } 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::Visual::Base((const Dali::Toolkit::Visual::Base &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_EnableVisual(void * jarg1, int jarg2, unsigned int jarg3) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + bool arg3 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + arg3 = jarg3 ? true : false; + { + try { + (arg1)->EnableVisual(arg2,arg3); + } 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_ViewWrapperImpl_IsVisualEnabled(void * jarg1, int jarg2) { + unsigned int jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = (bool)((Dali::Toolkit::Internal::ControlWrapper const *)arg1)->IsVisualEnabled(arg2); + } 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_ViewWrapperImpl_CreateTransition(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Toolkit::TransitionData *arg2 = 0 ; + Dali::Animation result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Toolkit::TransitionData *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->CreateTransition((Dali::Toolkit::TransitionData const &)*arg2); + } 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::Animation((const Dali::Animation &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_EmitKeyInputFocusSignal(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->EmitKeyInputFocusSignal(arg2); + } 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_ViewWrapperImpl_ApplyThemeStyle(void * jarg1) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + { + try { + (arg1)->ApplyThemeStyle(); + } 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/plugins/dali-swig/manual/cpp/view-wrapper-impl-wrap.h b/plugins/dali-swig/manual/cpp/view-wrapper-impl-wrap.h new file mode 100644 index 0000000..f95d74a --- /dev/null +++ b/plugins/dali-swig/manual/cpp/view-wrapper-impl-wrap.h @@ -0,0 +1,235 @@ +#ifndef CSHARP_VIEW_WRAPPER_IMPL_H +#define CSHARP_VIEW_WRAPPER_IMPL_H + +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include "common.h" + +class SwigDirector_ViewWrapperImpl : public Dali::Toolkit::Internal::ControlWrapper +{ +public: + + SwigDirector_ViewWrapperImpl(Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour behaviourFlags); + virtual ~SwigDirector_ViewWrapperImpl(); + virtual void OnStageConnection(int depth); + virtual void OnStageConnectionSwigPublic(int depth) + { + Dali::Toolkit::Internal::Control::OnStageConnection(depth); + } + virtual void OnStageDisconnection(); + virtual void OnStageDisconnectionSwigPublic() + { + Dali::Toolkit::Internal::Control::OnStageDisconnection(); + } + virtual void OnChildAdd(Dali::Actor &child); + virtual void OnChildAddSwigPublic(Dali::Actor &child) + { + Dali::Toolkit::Internal::Control::OnChildAdd(child); + } + virtual void OnChildRemove(Dali::Actor &child); + virtual void OnChildRemoveSwigPublic(Dali::Actor &child) + { + Dali::Toolkit::Internal::Control::OnChildRemove(child); + } + virtual void OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue); + virtual void OnSizeSet(Dali::Vector3 const &targetSize); + virtual void OnSizeSetSwigPublic(Dali::Vector3 const &targetSize) + { + Dali::Toolkit::Internal::Control::OnSizeSet(targetSize); + } + virtual void OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize); + virtual void OnSizeAnimationSwigPublic(Dali::Animation &animation, Dali::Vector3 const &targetSize) + { + Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize); + } + virtual bool OnTouchEvent(Dali::TouchEvent const &event); + virtual bool OnTouchEventSwigPublic(Dali::TouchEvent const &event) + { + return Dali::Toolkit::Internal::Control::OnTouchEvent(event); + } + virtual bool OnHoverEvent(Dali::HoverEvent const &event); + virtual bool OnHoverEventSwigPublic(Dali::HoverEvent const &event) + { + return Dali::Toolkit::Internal::Control::OnHoverEvent(event); + } + virtual bool OnKeyEvent(Dali::KeyEvent const &event); + virtual bool OnKeyEventSwigPublic(Dali::KeyEvent const &event) + { + return Dali::Toolkit::Internal::Control::OnKeyEvent(event); + } + virtual bool OnWheelEvent(Dali::WheelEvent const &event); + virtual bool OnWheelEventSwigPublic(Dali::WheelEvent const &event) + { + return Dali::Toolkit::Internal::Control::OnWheelEvent(event); + } + virtual void OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container); + virtual void OnRelayoutSwigPublic(Dali::Vector2 const &size, Dali::RelayoutContainer &container) + { + Dali::Toolkit::Internal::Control::OnRelayout(size,container); + } + virtual void OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension); + virtual void OnSetResizePolicySwigPublic(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) + { + Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension); + } + virtual Dali::Vector3 GetNaturalSize(); + virtual Dali::Vector3 GetNaturalSizeSwigPublic() + { + return Dali::Toolkit::Internal::Control::GetNaturalSize(); + } + virtual float CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension); + virtual float CalculateChildSizeSwigPublic(Dali::Actor const &child, Dali::Dimension::Type dimension) + { + return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension); + } + virtual float GetHeightForWidth(float width); + virtual float GetHeightForWidthSwigPublic(float width) + { + return Dali::Toolkit::Internal::Control::GetHeightForWidth(width); + } + virtual float GetWidthForHeight(float height); + virtual float GetWidthForHeightSwigPublic(float height) + { + return Dali::Toolkit::Internal::Control::GetWidthForHeight(height); + } + virtual bool RelayoutDependentOnChildren(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS); + virtual bool RelayoutDependentOnChildrenSwigPublic(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS) + { + return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension); + } + virtual void OnCalculateRelayoutSize(Dali::Dimension::Type dimension); + virtual void OnCalculateRelayoutSizeSwigPublic(Dali::Dimension::Type dimension) + { + Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension); + } + virtual void OnLayoutNegotiated(float size, Dali::Dimension::Type dimension); + virtual void OnLayoutNegotiatedSwigPublic(float size, Dali::Dimension::Type dimension) + { + Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension); + } + virtual void OnInitialize(); + virtual void OnControlChildAdd(Dali::Actor &child); + virtual void OnControlChildRemove(Dali::Actor &child); + virtual void OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change); + virtual bool OnAccessibilityActivated(); + virtual bool OnAccessibilityPan(Dali::PanGesture gesture); + virtual bool OnAccessibilityTouch(Dali::TouchEvent const &touchEvent); + virtual bool OnAccessibilityValueChange(bool isIncrease); + virtual bool OnAccessibilityZoom(); + virtual void OnKeyInputFocusGained(); + virtual void OnKeyInputFocusLost(); + virtual Dali::Actor GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled); + virtual void OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor); + virtual bool OnKeyboardEnter(); + virtual void OnPinch(Dali::PinchGesture const &pinch); + virtual void OnPan(Dali::PanGesture const &pan); + virtual void OnTap(Dali::TapGesture const &tap); + virtual void OnLongPress(Dali::LongPressGesture const &longPress); + virtual void SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback); + virtual void SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback); + virtual Dali::Toolkit::Internal::Control::Extension *GetControlExtension(); + + typedef void (SWIGSTDCALL* SWIG_Callback0_t)(int); + typedef void (SWIGSTDCALL* SWIG_Callback1_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback2_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback3_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback4_t)(int, void *); + typedef void (SWIGSTDCALL* SWIG_Callback5_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback6_t)(void *, void *); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback7_t)(void *); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback8_t)(void *); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback9_t)(void *); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback10_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback11_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback12_t)(int, int); + typedef void * (SWIGSTDCALL* SWIG_Callback13_t)(); + typedef float (SWIGSTDCALL* SWIG_Callback14_t)(void *, int); + typedef float (SWIGSTDCALL* SWIG_Callback15_t)(float); + typedef float (SWIGSTDCALL* SWIG_Callback16_t)(float); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback17_t)(int); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback18_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback19_t)(int); + typedef void (SWIGSTDCALL* SWIG_Callback20_t)(float, int); + typedef void (SWIGSTDCALL* SWIG_Callback21_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback22_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback23_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback24_t)(void *, int); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback25_t)(); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback26_t)(void *); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback27_t)(void *); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback28_t)(unsigned int); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback29_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback30_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback31_t)(); + typedef void * (SWIGSTDCALL* SWIG_Callback32_t)(void *, int, unsigned int); + typedef void (SWIGSTDCALL* SWIG_Callback33_t)(void *); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback34_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback35_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback36_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback37_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback38_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback39_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback40_t)(void *, void *); + void swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected); + +private: + SWIG_Callback0_t swig_callbackOnStageConnection; + SWIG_Callback1_t swig_callbackOnStageDisconnection; + SWIG_Callback2_t swig_callbackOnChildAdd; + SWIG_Callback3_t swig_callbackOnChildRemove; + SWIG_Callback4_t swig_callbackOnPropertySet; + SWIG_Callback5_t swig_callbackOnSizeSet; + SWIG_Callback6_t swig_callbackOnSizeAnimation; + SWIG_Callback7_t swig_callbackOnTouchEvent; + SWIG_Callback8_t swig_callbackOnHoverEvent; + SWIG_Callback9_t swig_callbackOnKeyEvent; + SWIG_Callback10_t swig_callbackOnWheelEvent; + SWIG_Callback11_t swig_callbackOnRelayout; + SWIG_Callback12_t swig_callbackOnSetResizePolicy; + SWIG_Callback13_t swig_callbackGetNaturalSize; + SWIG_Callback14_t swig_callbackCalculateChildSize; + SWIG_Callback15_t swig_callbackGetHeightForWidth; + SWIG_Callback16_t swig_callbackGetWidthForHeight; + SWIG_Callback17_t swig_callbackRelayoutDependentOnChildren__SWIG_0; + SWIG_Callback18_t swig_callbackRelayoutDependentOnChildren__SWIG_1; + SWIG_Callback19_t swig_callbackOnCalculateRelayoutSize; + SWIG_Callback20_t swig_callbackOnLayoutNegotiated; + SWIG_Callback21_t swig_callbackOnInitialize; + SWIG_Callback22_t swig_callbackOnControlChildAdd; + SWIG_Callback23_t swig_callbackOnControlChildRemove; + SWIG_Callback24_t swig_callbackOnStyleChange; + SWIG_Callback25_t swig_callbackOnAccessibilityActivated; + SWIG_Callback26_t swig_callbackOnAccessibilityPan; + SWIG_Callback27_t swig_callbackOnAccessibilityTouch; + SWIG_Callback28_t swig_callbackOnAccessibilityValueChange; + SWIG_Callback29_t swig_callbackOnAccessibilityZoom; + SWIG_Callback30_t swig_callbackOnKeyInputFocusGained; + SWIG_Callback31_t swig_callbackOnKeyInputFocusLost; + SWIG_Callback32_t swig_callbackGetNextKeyboardFocusableActor; + SWIG_Callback33_t swig_callbackOnKeyboardFocusChangeCommitted; + SWIG_Callback34_t swig_callbackOnKeyboardEnter; + SWIG_Callback35_t swig_callbackOnPinch; + SWIG_Callback36_t swig_callbackOnPan; + SWIG_Callback37_t swig_callbackOnTap; + SWIG_Callback38_t swig_callbackOnLongPress; + SWIG_Callback39_t swig_callbackSignalConnected; + SWIG_Callback40_t swig_callbackSignalDisconnected; + void swig_init_callbacks(); +}; + +#endif /* CSHARP_VIEW_WRAPPER_IMPL_H */ diff --git a/plugins/dali-swig/manual/csharp/CustomView.cs b/plugins/dali-swig/manual/csharp/CustomView.cs new file mode 100644 index 0000000..f704885 --- /dev/null +++ b/plugins/dali-swig/manual/csharp/CustomView.cs @@ -0,0 +1,824 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +namespace Dali +{ + public class CustomView : ViewWrapper + { + public CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour) : base(new ViewWrapperImpl(behaviour)) + { + // Registering CustomView virtual functions to viewWrapperImpl delegates. + viewWrapperImpl.OnStageConnection = new ViewWrapperImpl.OnStageConnectionDelegate(OnStageConnection); + viewWrapperImpl.OnStageDisconnection = new ViewWrapperImpl.OnStageDisconnectionDelegate(OnStageDisconnection); + viewWrapperImpl.OnChildAdd = new ViewWrapperImpl.OnChildAddDelegate(OnChildAdd); + viewWrapperImpl.OnChildRemove = new ViewWrapperImpl.OnChildRemoveDelegate(OnChildRemove); + viewWrapperImpl.OnPropertySet = new ViewWrapperImpl.OnPropertySetDelegate(OnPropertySet); + viewWrapperImpl.OnSizeSet = new ViewWrapperImpl.OnSizeSetDelegate(OnSizeSet); + viewWrapperImpl.OnSizeAnimation = new ViewWrapperImpl.OnSizeAnimationDelegate(OnSizeAnimation); + viewWrapperImpl.OnTouchEvent = new ViewWrapperImpl.OnTouchEventDelegate(OnTouchEvent); + viewWrapperImpl.OnHoverEvent = new ViewWrapperImpl.OnHoverEventDelegate(OnHoverEvent); + viewWrapperImpl.OnKeyEvent = new ViewWrapperImpl.OnKeyEventDelegate(OnKeyEvent); + viewWrapperImpl.OnWheelEvent = new ViewWrapperImpl.OnWheelEventDelegate(OnWheelEvent); + viewWrapperImpl.OnRelayout = new ViewWrapperImpl.OnRelayoutDelegate(OnRelayout); + viewWrapperImpl.OnSetResizePolicy = new ViewWrapperImpl.OnSetResizePolicyDelegate(OnSetResizePolicy); + viewWrapperImpl.GetNaturalSize = new ViewWrapperImpl.GetNaturalSizeDelegate(GetNaturalSize); + viewWrapperImpl.CalculateChildSize = new ViewWrapperImpl.CalculateChildSizeDelegate(CalculateChildSize); + viewWrapperImpl.GetHeightForWidth = new ViewWrapperImpl.GetHeightForWidthDelegate(GetHeightForWidth); + viewWrapperImpl.GetWidthForHeight = new ViewWrapperImpl.GetWidthForHeightDelegate(GetWidthForHeight); + viewWrapperImpl.RelayoutDependentOnChildrenDimension = new ViewWrapperImpl.RelayoutDependentOnChildrenDimensionDelegate(RelayoutDependentOnChildren); + viewWrapperImpl.RelayoutDependentOnChildren = new ViewWrapperImpl.RelayoutDependentOnChildrenDelegate(RelayoutDependentOnChildren); + viewWrapperImpl.OnCalculateRelayoutSize = new ViewWrapperImpl.OnCalculateRelayoutSizeDelegate(OnCalculateRelayoutSize); + viewWrapperImpl.OnLayoutNegotiated = new ViewWrapperImpl.OnLayoutNegotiatedDelegate(OnLayoutNegotiated); + viewWrapperImpl.OnControlChildAdd = new ViewWrapperImpl.OnControlChildAddDelegate(OnControlChildAdd); + viewWrapperImpl.OnControlChildRemove = new ViewWrapperImpl.OnControlChildRemoveDelegate(OnControlChildRemove); + viewWrapperImpl.OnStyleChange = new ViewWrapperImpl.OnStyleChangeDelegate(OnStyleChange); + viewWrapperImpl.OnAccessibilityActivated = new ViewWrapperImpl.OnAccessibilityActivatedDelegate(OnAccessibilityActivated); + viewWrapperImpl.OnAccessibilityPan = new ViewWrapperImpl.OnAccessibilityPanDelegate(OnAccessibilityPan); + viewWrapperImpl.OnAccessibilityTouch = new ViewWrapperImpl.OnAccessibilityTouchDelegate(OnAccessibilityTouch); + viewWrapperImpl.OnAccessibilityValueChange = new ViewWrapperImpl.OnAccessibilityValueChangeDelegate(OnAccessibilityValueChange); + viewWrapperImpl.OnAccessibilityZoom = new ViewWrapperImpl.OnAccessibilityZoomDelegate(OnAccessibilityZoom); + viewWrapperImpl.OnKeyInputFocusGained = new ViewWrapperImpl.OnKeyInputFocusGainedDelegate(OnKeyInputFocusGained); + viewWrapperImpl.OnKeyInputFocusLost = new ViewWrapperImpl.OnKeyInputFocusLostDelegate(OnKeyInputFocusLost); + viewWrapperImpl.GetNextKeyboardFocusableActor = new ViewWrapperImpl.GetNextKeyboardFocusableActorDelegate(GetNextKeyboardFocusableActor); + viewWrapperImpl.OnKeyboardFocusChangeCommitted = new ViewWrapperImpl.OnKeyboardFocusChangeCommittedDelegate(OnKeyboardFocusChangeCommitted); + viewWrapperImpl.OnKeyboardEnter = new ViewWrapperImpl.OnKeyboardEnterDelegate(OnKeyboardEnter); + viewWrapperImpl.OnPinch = new ViewWrapperImpl.OnPinchDelegate(OnPinch); + viewWrapperImpl.OnPan = new ViewWrapperImpl.OnPanDelegate(OnPan); + viewWrapperImpl.OnTap = new ViewWrapperImpl.OnTapDelegate(OnTap); + viewWrapperImpl.OnLongPress = new ViewWrapperImpl.OnLongPressDelegate(OnLongPress); + viewWrapperImpl.SignalConnected = new ViewWrapperImpl.SignalConnectedDelegate(SignalConnected); + viewWrapperImpl.SignalDisconnected = new ViewWrapperImpl.SignalDisconnectedDelegate(SignalDisconnected); + + // Make sure CustomView is initialized. + OnInitialize(); + + // Make sure the style of actors/visuals initialized above are applied by the style manager. + viewWrapperImpl.ApplyThemeStyle(); + } + + /** + * @brief Set the background with a property map. + * + * @param[in] map The background property map. + */ + public void SetBackground(Dali.Property.Map map) + { + viewWrapperImpl.SetBackground(map); + } + + /** + * @brief Allows deriving classes to enable any of the gesture detectors that are available. + * + * Gesture detection can be enabled one at a time or in bitwise format as shown: + * @code + * EnableGestureDetection(Gesture.Type.Pinch | Gesture.Type.Tap | Gesture.Type.Pan)); + * @endcode + * @param[in] type The gesture type(s) to enable. + */ + public void EnableGestureDetection(Gesture.Type type) + { + viewWrapperImpl.EnableGestureDetection(type); + } + + /** + * @brief Allows deriving classes to disable any of the gesture detectors. + * + * Like EnableGestureDetection, this can also be called using bitwise or. + * @param[in] type The gesture type(s) to disable. + * @see EnableGetureDetection + */ + public void DisableGestureDetection(Gesture.Type type) + { + viewWrapperImpl.DisableGestureDetection(type); + } + + /** + * @brief Sets whether this control supports two dimensional + * keyboard navigation (i.e. whether it knows how to handle the + * keyboard focus movement between its child actors). + * + * The control doesn't support it by default. + * @param[in] isSupported Whether this control supports two dimensional keyboard navigation. + */ + public void SetKeyboardNavigationSupport(bool isSupported) + { + viewWrapperImpl.SetKeyboardNavigationSupport(isSupported); + } + + /** + * @brief Gets whether this control supports two dimensional keyboard navigation. + * + * @return true if this control supports two dimensional keyboard navigation. + */ + public bool IsKeyboardNavigationSupported() + { + return viewWrapperImpl.IsKeyboardNavigationSupported(); + } + + /** + * @brief Sets whether this control is a focus group for keyboard navigation. + * + * (i.e. the scope of keyboard focus movement + * can be limitied to its child actors). The control is not a focus group by default. + * @param[in] isFocusGroup Whether this control is set as a focus group for keyboard navigation. + */ + public void SetAsKeyboardFocusGroup(bool isFocusGroup) + { + viewWrapperImpl.SetAsKeyboardFocusGroup(isFocusGroup); + } + + /** + * @brief Gets whether this control is a focus group for keyboard navigation. + * + * @return true if this control is set as a focus group for keyboard navigation. + */ + public bool IsKeyboardFocusGroup() + { + return viewWrapperImpl.IsKeyboardFocusGroup(); + } + + /** + * @brief Called by the AccessibilityManager to activate the Control. + * @SINCE_1_0.0 + */ + public void AccessibilityActivate() + { + viewWrapperImpl.AccessibilityActivate(); + } + + /** + * @brief Called by the KeyboardFocusManager. + */ + public void KeyboardEnter() + { + viewWrapperImpl.KeyboardEnter(); + } + + /** + * @brief Called by the KeyInputFocusManager to emit key event signals. + * + * @param[in] keyEvent The key event. + * @return True if the event was consumed. + */ + public bool EmitKeyEventSignal(KeyEvent keyEvent) + { + return viewWrapperImpl.EmitKeyEventSignal(keyEvent); + } + + /** + * @brief Request a relayout, which means performing a size negotiation on this actor, its parent and children (and potentially whole scene). + * + * This method can also be called from a derived class every time it needs a different size. + * At the end of event processing, the relayout process starts and + * all controls which requested Relayout will have their sizes (re)negotiated. + * + * @note RelayoutRequest() can be called multiple times; the size negotiation is still + * only performed once, i.e. there is no need to keep track of this in the calling side. + */ + protected void RelayoutRequest() + { + viewWrapperImpl.RelayoutRequest(); + } + + /** + * @brief Provides the Actor implementation of GetHeightForWidth. + * @param width Width to use. + * @return The height based on the width. + */ + protected float GetHeightForWidthBase(float width) + { + return viewWrapperImpl.GetHeightForWidthBase( width ); + } + + /** + * @brief Provides the Actor implementation of GetWidthForHeight. + * @param height Height to use. + * @return The width based on the height. + */ + protected float GetWidthForHeightBase(float height) + { + return viewWrapperImpl.GetWidthForHeightBase( height ); + } + + /** + * @brief Calculate the size for a child using the base actor object. + * + * @param[in] child The child actor to calculate the size for + * @param[in] dimension The dimension to calculate the size for. E.g. width or height + * @return Return the calculated size for the given dimension. If more than one dimension is requested, just return the first one found. + */ + protected float CalculateChildSizeBase(Actor child, DimensionType dimension) + { + return viewWrapperImpl.CalculateChildSizeBase( child, dimension ); + } + + /** + * @brief Determine if this actor is dependent on it's children for relayout from the base class. + * + * @param dimension The dimension(s) to check for + * @return Return if the actor is dependent on it's children. + */ + protected bool RelayoutDependentOnChildrenBase(DimensionType dimension) + { + return viewWrapperImpl.RelayoutDependentOnChildrenBase( dimension ); + } + + /** + * @brief Determine if this actor is dependent on it's children for relayout from the base class. + * + * @param dimension The dimension(s) to check for + * @return Return if the actor is dependent on it's children. + */ + protected bool RelayoutDependentOnChildrenBase() + { + return viewWrapperImpl.RelayoutDependentOnChildrenBase(); + } + + /** + * @brief Register a visual by Property Index, linking an Actor to visual when required. + * In the case of the visual being an actor or control deeming visual not required then visual should be an empty handle. + * No parenting is done during registration, this should be done by derived class. + * + * @param[in] index The Property index of the visual, used to reference visual + * @param[in] visual The visual to register + * @note Derived class should not call visual.SetOnStage(actor). It is the responsibility of the base class to connect/disconnect registered visual to stage. + * Use below API with enabled set to false if derived class wishes to control when visual is staged. + */ + protected void RegisterVisual(int index, VisualBase visual) + { + viewWrapperImpl.RegisterVisual( index, visual ); + } + + /** + * @brief Register a visual by Property Index, linking an Actor to visual when required. + * In the case of the visual being an actor or control deeming visual not required then visual should be an empty handle. + * If enabled is false then the visual is not set on stage until enabled by the derived class. + * @see EnableVisual + * + * @param[in] index The Property index of the visual, used to reference visual + * @param[in] visual The visual to register + * @param[in] enabled false if derived class wants to control when visual is set on stage. + * + */ + protected void RegisterVisual(int index, VisualBase visual, bool enabled) + { + viewWrapperImpl.RegisterVisual( index, visual, enabled ); + } + + /** + * @brief Erase the entry matching the given index from the list of registered visuals + * @param[in] index The Property index of the visual, used to reference visual + * + */ + protected void UnregisterVisual(int index) + { + viewWrapperImpl.UnregisterVisual( index ); + } + + /** + * @brief Retrieve the visual associated with the given property index. + * + * @param[in] index The Property index of the visual. + * @return The registered visual if exist, otherwise empty handle. + * @note For managing object life-cycle, do not store the returned visual as a member which increments its reference count. + */ + protected VisualBase GetVisual(int index) + { + return viewWrapperImpl.GetVisual( index ); + } + + /** + * @brief Sets the given visual to be displayed or not when parent staged. + * + * @param[in] index The Property index of the visual + * @param[in] enable flag to set enabled or disabled. + */ + protected void EnableVisual(int index, bool enable) + { + viewWrapperImpl.EnableVisual( index, enable ); + } + + /** + * @brief Queries if the given visual is to be displayed when parent staged. + * + * @param[in] index The Property index of the visual + * @return bool whether visual is enabled or not + */ + protected bool IsVisualEnabled(int index) + { + return viewWrapperImpl.IsVisualEnabled( index ); + } + + /** + * @brief Create a transition effect on the control. + * + * @param[in] transitionData The transition data describing the effect to create + * @return A handle to an animation defined with the given effect, or an empty + * handle if no properties match. + */ + protected Animation CreateTransition(TransitionData transitionData) + { + return viewWrapperImpl.CreateTransition( transitionData ); + } + + /** + * @brief Emits KeyInputFocusGained signal if true else emits KeyInputFocusLost signal + * + * Should be called last by the control after it acts on the Input Focus change. + * + * @param[in] focusGained True if gained, False if lost + */ + protected void EmitKeyInputFocusSignal(bool focusGained) + { + viewWrapperImpl.EmitKeyInputFocusSignal( focusGained ); + } + + /** + * @brief This method is called after the Control has been initialized. + * + * Derived classes should do any second phase initialization by overriding this method. + */ + public virtual void OnInitialize() + { + } + + /** + * @brief Called after the actor has been connected to the stage. + * + * When an actor is connected, it will be directly or indirectly parented to the root Actor. + * @param[in] depth The depth in the hierarchy for the actor + * + * @note The root Actor is provided automatically by Dali::Stage, and is always considered to be connected. + * When the parent of a set of actors is connected to the stage, then all of the children + * will received this callback. + * For the following actor tree, the callback order will be A, B, D, E, C, and finally F. + * + * @code + * + * A (parent) + * / \ + * B C + * / \ \ + * D E F + * + * @endcode + * @param[in] depth The depth in the hierarchy for the actor + */ + public virtual void OnStageConnection(int depth) + { + } + + /** + * @brief Called after the actor has been disconnected from Stage. + * + * If an actor is disconnected it either has no parent, or is parented to a disconnected actor. + * + * @note When the parent of a set of actors is disconnected to the stage, then all of the children + * will received this callback, starting with the leaf actors. + * For the following actor tree, the callback order will be D, E, B, F, C, and finally A. + * + * @code + * + * A (parent) + * / \ + * B C + * / \ \ + * D E F + * + * @endcode + */ + public virtual void OnStageDisconnection() + { + } + + /** + * @brief Called after a child has been added to the owning actor. + * + * @param[in] child The child which has been added + */ + public virtual void OnChildAdd(Actor actor) + { + } + + /** + * @brief Called after the owning actor has attempted to remove a child( regardless of whether it succeeded or not ). + * + * @param[in] child The child being removed + */ + public virtual void OnChildRemove(Actor actor) + { + } + + /** + * @brief Called when the owning actor property is set. + * + * @param[in] index The Property index that was set + * @param[in] propertyValue The value to set + */ + public virtual void OnPropertySet(int index, Dali.Property.Value propertyValue) + { + } + + /** + * @brief Called when the owning actor's size is set e.g. using Actor::SetSize(). + * + * @param[in] targetSize The target size. Note that this target size may not match the size returned via Actor.GetTargetSize. + */ + public virtual void OnSizeSet(Vector3 targetSize) + { + } + + /** + * @brief Called when the owning actor's size is animated e.g. using Animation::AnimateTo( Property( actor, Actor::Property::SIZE ), ... ). + * + * @param[in] animation The object which is animating the owning actor. + * @param[in] targetSize The target size. Note that this target size may not match the size returned via @ref Actor.GetTargetSize. + */ + public virtual void OnSizeAnimation(Animation animation, Vector3 targetSize) + { + } + + /** + * @DEPRECATED_1_1.37 Connect to TouchSignal() instead. + * + * @brief Called after a touch-event is received by the owning actor. + * + * @param[in] event The touch event + * @return True if the event should be consumed. + * @note CustomViewBehaviour.REQUIRES_TOUCH_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour). + */ + public virtual bool OnTouchEvent(TouchEvent touchEvent) + { + return false; // Do not consume + } + + /** + * @brief Called after a hover-event is received by the owning actor. + * + * @param[in] event The hover event + * @return True if the event should be consumed. + * @note CustomViewBehaviour.REQUIRES_HOVER_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour). + */ + public virtual bool OnHoverEvent(HoverEvent hoverEvent) + { + return false; // Do not consume + } + + /** + * @brief Called after a key-event is received by the actor that has had its focus set. + * + * @param[in] event the Key Event + * @return True if the event should be consumed. + */ + public virtual bool OnKeyEvent(KeyEvent keyEvent) + { + return false; // Do not consume + } + + /** + * @brief Called after a wheel-event is received by the owning actor. + * + * @param[in] event The wheel event + * @return True if the event should be consumed. + * @note CustomViewBehaviour.REQUIRES_WHEEL_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour). + */ + public virtual bool OnWheelEvent(WheelEvent wheelEvent) + { + return false; // Do not consume + } + + /** + * @brief Called after the size negotiation has been finished for this control. + * + * The control is expected to assign this given size to itself/its children. + * + * Should be overridden by derived classes if they need to layout + * actors differently after certain operations like add or remove + * actors, resize or after changing specific properties. + * + * @param[in] size The allocated size. + * @param[in,out] container The control should add actors to this container that it is not able + * to allocate a size for. + * @note As this function is called from inside the size negotiation algorithm, you cannot + * call RequestRelayout (the call would just be ignored). + */ + public virtual void OnRelayout(Vector2 size, RelayoutContainer container) + { + } + + /** + * @brief Notification for deriving classes + * + * @param[in] policy The policy being set + * @param[in] dimension The dimension the policy is being set for + */ + public virtual void OnSetResizePolicy(ResizePolicyType policy, DimensionType dimension) + { + } + + /** + * @brief Return the natural size of the actor. + * + * @return The actor's natural size + */ + public virtual Vector3 GetNaturalSize() + { + return new Vector3(0.0f, 0.0f, 0.0f); + } + + /** + * @brief Calculate the size for a child. + * + * @param[in] child The child actor to calculate the size for + * @param[in] dimension The dimension to calculate the size for. E.g. width or height. + * @return Return the calculated size for the given dimension. + */ + public virtual float CalculateChildSize(Actor child, DimensionType dimension) + { + return viewWrapperImpl.CalculateChildSizeBase( child, dimension ); + } + + /** + * @brief This method is called during size negotiation when a height is required for a given width. + * + * Derived classes should override this if they wish to customize the height returned. + * + * @param width Width to use. + * @return The height based on the width. + */ + public virtual float GetHeightForWidth(float width) + { + return viewWrapperImpl.GetHeightForWidthBase( width ); + } + + /** + * @brief This method is called during size negotiation when a width is required for a given height. + * + * Derived classes should override this if they wish to customize the width returned. + * + * @param height Height to use. + * @return The width based on the width. + */ + public virtual float GetWidthForHeight(float height) + { + return viewWrapperImpl.GetWidthForHeightBase( height ); + } + + /** + * @brief Determine if this actor is dependent on it's children for relayout. + * + * @param dimension The dimension(s) to check for + * @return Return if the actor is dependent on it's children. + */ + public virtual bool RelayoutDependentOnChildren(DimensionType dimension) + { + return viewWrapperImpl.RelayoutDependentOnChildrenBase( dimension ); + } + + /** + * @brief Determine if this actor is dependent on it's children for relayout from the base class. + * + * @return Return if the actor is dependent on it's children. + */ + public virtual bool RelayoutDependentOnChildren() + { + return viewWrapperImpl.RelayoutDependentOnChildrenBase(); + } + + /** + * @brief Virtual method to notify deriving classes that relayout dependencies have been + * met and the size for this object is about to be calculated for the given dimension + * + * @param dimension The dimension that is about to be calculated + */ + public virtual void OnCalculateRelayoutSize(DimensionType dimension) + { + } + + /** + * @brief Virtual method to notify deriving classes that the size for a dimension + * has just been negotiated + * + * @param[in] size The new size for the given dimension + * @param[in] dimension The dimension that was just negotiated + */ + public virtual void OnLayoutNegotiated(float size, DimensionType dimension) + { + } + + /** + * @brief This method should be overridden by deriving classes requiring notifications when the style changes. + * + * @param[in] styleManager The StyleManager object. + * @param[in] change Information denoting what has changed. + */ + public virtual void OnStyleChange(StyleManager styleManager, StyleChangeType change) + { + } + + /** + * @brief This method is called when the control is accessibility activated. + * + * Derived classes should override this to perform custom accessibility activation. + * @return true if this control can perform accessibility activation. + */ + public virtual bool OnAccessibilityActivated() + { + return false; + } + + /** + * @brief This method should be overridden by deriving classes when they wish to respond the accessibility + * pan gesture. + * + * @param[in] gesture The pan gesture. + * @return true if the pan gesture has been consumed by this control + */ + public virtual bool OnAccessibilityPan(PanGesture gestures) + { + return false; + } + + /** + * @brief This method should be overridden by deriving classes when they wish to respond the accessibility + * touch event. + * + * @param[in] touchEvent The touch event. + * @return true if the touch event has been consumed by this control + */ + public virtual bool OnAccessibilityTouch(TouchEvent touchEvent) + { + return false; + } + + /** + * @brief This method should be overridden by deriving classes when they wish to respond + * the accessibility up and down action (i.e. value change of slider control). + * + * @param[in] isIncrease Whether the value should be increased or decreased + * @return true if the value changed action has been consumed by this control + */ + public virtual bool OnAccessibilityValueChange(bool isIncrease) + { + return false; + } + + /** + * @brief This method should be overridden by deriving classes when they wish to respond + * the accessibility zoom action. + * + * @return true if the zoom action has been consumed by this control + */ + public virtual bool OnAccessibilityZoom() + { + return false; + } + + /** + * @brief This method should be overridden by deriving classes when they wish to respond + * the accessibility zoom action. + * + * @return true if the zoom action has been consumed by this control + */ + public virtual void OnKeyInputFocusGained() + { + } + + /** + * @brief Called when the control loses key input focus. + * + * Should be overridden by derived classes if they need to customize what happens when focus is lost. + */ + public virtual void OnKeyInputFocusLost() + { + } + + /** + * @brief Gets the next keyboard focusable actor in this control towards the given direction. + * + * A control needs to override this function in order to support two dimensional keyboard navigation. + * @param[in] currentFocusedActor The current focused actor. + * @param[in] direction The direction to move the focus towards. + * @param[in] loopEnabled Whether the focus movement should be looped within the control. + * @return the next keyboard focusable actor in this control or an empty handle if no actor can be focused. + */ + public virtual Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, View.KeyboardFocus.Direction direction, bool loopEnabled) + { + return new Actor(); + } + + /** + * @brief Informs this control that its chosen focusable actor will be focused. + * + * This allows the application to preform any actions if wishes + * before the focus is actually moved to the chosen actor. + * + * @param[in] commitedFocusableActor The commited focusable actor. + */ + public virtual void OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor) + { + } + + /** + * @brief This method is called when the control has enter pressed on it. + * + * Derived classes should override this to perform custom actions. + * @return true if this control supported this action. + */ + public virtual bool OnKeyboardEnter() + { + return false; + } + + /** + * @brief Called whenever a pinch gesture is detected on this control. + * + * This can be overridden by deriving classes when pinch detection + * is enabled. The default behaviour is to scale the control by the + * pinch scale. + * + * @param[in] pinch The pinch gesture. + * @note If overridden, then the default behaviour will not occur. + * @note Pinch detection should be enabled via EnableGestureDetection(). + * @see EnableGestureDetection + */ + public virtual void OnPinch(PinchGesture pinch) + { + } + + /** + * @brief Called whenever a pan gesture is detected on this control. + * + * This should be overridden by deriving classes when pan detection + * is enabled. + * + * @param[in] pan The pan gesture. + * @note There is no default behaviour with panning. + * @note Pan detection should be enabled via EnableGestureDetection(). + * @see EnableGestureDetection + */ + public virtual void OnPan(PanGesture pan) + { + } + + /** + * @brief Called whenever a tap gesture is detected on this control. + * + * This should be overridden by deriving classes when tap detection + * is enabled. + * + * @param[in] tap The tap gesture. + * @note There is no default behaviour with a tap. + * @note Tap detection should be enabled via EnableGestureDetection(). + * @see EnableGestureDetection + */ + public virtual void OnTap(TapGesture tap) + { + } + + /** + * @brief Called whenever a long press gesture is detected on this control. + * + * This should be overridden by deriving classes when long press + * detection is enabled. + * + * @param[in] longPress The long press gesture. + * @note There is no default behaviour associated with a long press. + * @note Long press detection should be enabled via EnableGestureDetection(). + * @see EnableGestureDetection + */ + public virtual void OnLongPress(LongPressGesture longPress) + { + } + + private void SignalConnected(SlotObserver slotObserver, SWIGTYPE_p_Dali__CallbackBase callback) + { + } + + private void SignalDisconnected(SlotObserver slotObserver, SWIGTYPE_p_Dali__CallbackBase callback) + { + } + + private void OnControlChildAdd(Actor child) + { + } + + private void OnControlChildRemove(Actor child) + { + } + } +} diff --git a/plugins/dali-swig/manual/csharp/DaliEventHandler.cs b/plugins/dali-swig/manual/csharp/DaliEventHandler.cs index a7de698..80becbf 100644 --- a/plugins/dali-swig/manual/csharp/DaliEventHandler.cs +++ b/plugins/dali-swig/manual/csharp/DaliEventHandler.cs @@ -1,12 +1,28 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ namespace Dali { - using System; - using System.Runtime.InteropServices; + using System; + using System.Runtime.InteropServices; - [UnmanagedFunctionPointer(CallingConvention.StdCall)] - public delegate void DaliEventHandler(T source, U e); + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate void DaliEventHandler(T source, U e); - [UnmanagedFunctionPointer(CallingConvention.StdCall)] - public delegate R DaliEventHandlerWithReturnType(T source, U e); + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate R DaliEventHandlerWithReturnType(T source, U e); } diff --git a/plugins/dali-swig/manual/csharp/KeyboardFocusManager.cs b/plugins/dali-swig/manual/csharp/KeyboardFocusManager.cs index c02f122..6509966 100644 --- a/plugins/dali-swig/manual/csharp/KeyboardFocusManager.cs +++ b/plugins/dali-swig/manual/csharp/KeyboardFocusManager.cs @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + namespace Dali { using System; diff --git a/plugins/dali-swig/manual/csharp/KeyboardPreFocusChangeSignal.cs b/plugins/dali-swig/manual/csharp/KeyboardPreFocusChangeSignal.cs index 3556ffc..5980e96 100644 --- a/plugins/dali-swig/manual/csharp/KeyboardPreFocusChangeSignal.cs +++ b/plugins/dali-swig/manual/csharp/KeyboardPreFocusChangeSignal.cs @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + using System; namespace Dali { diff --git a/plugins/dali-swig/manual/csharp/ManualPINVOKE.cs b/plugins/dali-swig/manual/csharp/ManualPINVOKE.cs index 48196e3..782ad37 100644 --- a/plugins/dali-swig/manual/csharp/ManualPINVOKE.cs +++ b/plugins/dali-swig/manual/csharp/ManualPINVOKE.cs @@ -1,85 +1,187 @@ -namespace Dali { +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ -class NDalicManualPINVOKE { +namespace Dali +{ + class NDalicManualPINVOKE + { + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_new_KeyboardFocusManager")] + public static extern global::System.IntPtr new_KeyboardFocusManager(); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_new_KeyboardFocusManager")] - public static extern global::System.IntPtr new_KeyboardFocusManager(); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_delete_KeyboardFocusManager")] + public static extern void delete_KeyboardFocusManager(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_delete_KeyboardFocusManager")] - public static extern void delete_KeyboardFocusManager(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_Get")] + public static extern global::System.IntPtr KeyboardFocusManager_Get(); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_Get")] - public static extern global::System.IntPtr KeyboardFocusManager_Get(); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetCurrentFocusActor")] + public static extern bool KeyboardFocusManager_SetCurrentFocusActor(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetCurrentFocusActor")] - public static extern bool KeyboardFocusManager_SetCurrentFocusActor(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetCurrentFocusActor")] + public static extern global::System.IntPtr KeyboardFocusManager_GetCurrentFocusActor(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetCurrentFocusActor")] - public static extern global::System.IntPtr KeyboardFocusManager_GetCurrentFocusActor(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_MoveFocus")] + public static extern bool KeyboardFocusManager_MoveFocus(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_MoveFocus")] - public static extern bool KeyboardFocusManager_MoveFocus(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_ClearFocus")] + public static extern void KeyboardFocusManager_ClearFocus(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_ClearFocus")] - public static extern void KeyboardFocusManager_ClearFocus(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetFocusGroupLoop")] + public static extern void KeyboardFocusManager_SetFocusGroupLoop(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetFocusGroupLoop")] - public static extern void KeyboardFocusManager_SetFocusGroupLoop(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusGroupLoop")] + public static extern bool KeyboardFocusManager_GetFocusGroupLoop(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusGroupLoop")] - public static extern bool KeyboardFocusManager_GetFocusGroupLoop(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetAsFocusGroup")] + public static extern void KeyboardFocusManager_SetAsFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, bool jarg3); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetAsFocusGroup")] - public static extern void KeyboardFocusManager_SetAsFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, bool jarg3); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_IsFocusGroup")] + public static extern bool KeyboardFocusManager_IsFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_IsFocusGroup")] - public static extern bool KeyboardFocusManager_IsFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusGroup")] + public static extern global::System.IntPtr KeyboardFocusManager_GetFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusGroup")] - public static extern global::System.IntPtr KeyboardFocusManager_GetFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetFocusIndicatorActor")] + public static extern void KeyboardFocusManager_SetFocusIndicatorActor(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetFocusIndicatorActor")] - public static extern void KeyboardFocusManager_SetFocusIndicatorActor(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusIndicatorActor")] + public static extern global::System.IntPtr KeyboardFocusManager_GetFocusIndicatorActor(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusIndicatorActor")] - public static extern global::System.IntPtr KeyboardFocusManager_GetFocusIndicatorActor(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_PreFocusChangeSignal")] + public static extern global::System.IntPtr KeyboardFocusManager_PreFocusChangeSignal(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_PreFocusChangeSignal")] - public static extern global::System.IntPtr KeyboardFocusManager_PreFocusChangeSignal(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusChangedSignal")] + public static extern global::System.IntPtr KeyboardFocusManager_FocusChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusChangedSignal")] - public static extern global::System.IntPtr KeyboardFocusManager_FocusChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusGroupChangedSignal")] + public static extern global::System.IntPtr KeyboardFocusManager_FocusGroupChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusGroupChangedSignal")] - public static extern global::System.IntPtr KeyboardFocusManager_FocusGroupChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal")] + public static extern global::System.IntPtr KeyboardFocusManager_FocusedActorEnterKeySignal(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal")] - public static extern global::System.IntPtr KeyboardFocusManager_FocusedActorEnterKeySignal(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Empty")] + public static extern bool KeyboardPreFocusChangeSignal_Empty(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Empty")] - public static extern bool KeyboardPreFocusChangeSignal_Empty(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_GetConnectionCount")] + public static extern uint KeyboardPreFocusChangeSignal_GetConnectionCount(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_GetConnectionCount")] - public static extern uint KeyboardPreFocusChangeSignal_GetConnectionCount(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Connect")] + public static extern void KeyboardPreFocusChangeSignal_Connect(global::System.Runtime.InteropServices.HandleRef jarg1, KeyboardFocusManager.PreFocusChangeEventCallbackDelegate delegate1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Connect")] - public static extern void KeyboardPreFocusChangeSignal_Connect(global::System.Runtime.InteropServices.HandleRef jarg1, KeyboardFocusManager.PreFocusChangeEventCallbackDelegate delegate1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Disconnect")] + public static extern void KeyboardPreFocusChangeSignal_Disconnect(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Disconnect")] - public static extern void KeyboardPreFocusChangeSignal_Disconnect(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Emit")] + public static extern global::System.IntPtr KeyboardPreFocusChangeSignal_Emit(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, int jarg4); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Emit")] - public static extern global::System.IntPtr KeyboardPreFocusChangeSignal_Emit(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, int jarg4); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_new_KeyboardPreFocusChangeSignal")] + public static extern global::System.IntPtr new_KeyboardPreFocusChangeSignal(); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_new_KeyboardPreFocusChangeSignal")] - public static extern global::System.IntPtr new_KeyboardPreFocusChangeSignal(); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_delete_KeyboardPreFocusChangeSignal")] + public static extern void delete_KeyboardPreFocusChangeSignal(global::System.Runtime.InteropServices.HandleRef jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_delete_KeyboardPreFocusChangeSignal")] - public static extern void delete_KeyboardPreFocusChangeSignal(global::System.Runtime.InteropServices.HandleRef jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SWIGUpcast")] + public static extern global::System.IntPtr KeyboardFocusManager_SWIGUpcast(global::System.IntPtr jarg1); - [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SWIGUpcast")] - public static extern global::System.IntPtr KeyboardFocusManager_SWIGUpcast(global::System.IntPtr jarg1); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapperImpl_CONTROL_BEHAVIOUR_FLAG_COUNT_get")] + public static extern int ViewWrapperImpl_CONTROL_BEHAVIOUR_FLAG_COUNT_get(); -} + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_ViewWrapperImpl")] + public static extern global::System.IntPtr new_ViewWrapperImpl(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapperImpl_New")] + public static extern global::System.IntPtr ViewWrapperImpl_New(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_delete_ViewWrapperImpl")] + public static extern void delete_ViewWrapperImpl(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapperImpl_director_connect")] + public static extern void ViewWrapperImpl_director_connect(global::System.Runtime.InteropServices.HandleRef jarg1, ViewWrapperImpl.DelegateViewWrapperImpl_0 delegate0, ViewWrapperImpl.DelegateViewWrapperImpl_1 delegate1, ViewWrapperImpl.DelegateViewWrapperImpl_2 delegate2, ViewWrapperImpl.DelegateViewWrapperImpl_3 delegate3, ViewWrapperImpl.DelegateViewWrapperImpl_4 delegate4, ViewWrapperImpl.DelegateViewWrapperImpl_5 delegate5, ViewWrapperImpl.DelegateViewWrapperImpl_6 delegate6, ViewWrapperImpl.DelegateViewWrapperImpl_7 delegate7, ViewWrapperImpl.DelegateViewWrapperImpl_8 delegate8, ViewWrapperImpl.DelegateViewWrapperImpl_9 delegate9, ViewWrapperImpl.DelegateViewWrapperImpl_10 delegate10, ViewWrapperImpl.DelegateViewWrapperImpl_11 delegate11, ViewWrapperImpl.DelegateViewWrapperImpl_12 delegate12, ViewWrapperImpl.DelegateViewWrapperImpl_13 delegate13, ViewWrapperImpl.DelegateViewWrapperImpl_14 delegate14, ViewWrapperImpl.DelegateViewWrapperImpl_15 delegate15, ViewWrapperImpl.DelegateViewWrapperImpl_16 delegate16, ViewWrapperImpl.DelegateViewWrapperImpl_17 delegate17, ViewWrapperImpl.DelegateViewWrapperImpl_18 delegate18, ViewWrapperImpl.DelegateViewWrapperImpl_19 delegate19, ViewWrapperImpl.DelegateViewWrapperImpl_20 delegate20, ViewWrapperImpl.DelegateViewWrapperImpl_21 delegate21, ViewWrapperImpl.DelegateViewWrapperImpl_22 delegate22, ViewWrapperImpl.DelegateViewWrapperImpl_23 delegate23, ViewWrapperImpl.DelegateViewWrapperImpl_24 delegate24, ViewWrapperImpl.DelegateViewWrapperImpl_25 delegate25, ViewWrapperImpl.DelegateViewWrapperImpl_26 delegate26, ViewWrapperImpl.DelegateViewWrapperImpl_27 delegate27, ViewWrapperImpl.DelegateViewWrapperImpl_28 delegate28, ViewWrapperImpl.DelegateViewWrapperImpl_29 delegate29, ViewWrapperImpl.DelegateViewWrapperImpl_30 delegate30, ViewWrapperImpl.DelegateViewWrapperImpl_31 delegate31, ViewWrapperImpl.DelegateViewWrapperImpl_32 delegate32, ViewWrapperImpl.DelegateViewWrapperImpl_33 delegate33, ViewWrapperImpl.DelegateViewWrapperImpl_34 delegate34, ViewWrapperImpl.DelegateViewWrapperImpl_35 delegate35, ViewWrapperImpl.DelegateViewWrapperImpl_36 delegate36, ViewWrapperImpl.DelegateViewWrapperImpl_37 delegate37, ViewWrapperImpl.DelegateViewWrapperImpl_38 delegate38, ViewWrapperImpl.DelegateViewWrapperImpl_39 delegate39, ViewWrapperImpl.DelegateViewWrapperImpl_40 delegate40); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_GetControlWrapperImpl__SWIG_0")] + public static extern global::System.IntPtr GetControlWrapperImpl__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapper_New")] + public static extern global::System.IntPtr ViewWrapper_New(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_ViewWrapper__SWIG_0")] + public static extern global::System.IntPtr new_ViewWrapper__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_delete_ViewWrapper")] + public static extern void delete_ViewWrapper(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_ViewWrapper__SWIG_1")] + public static extern global::System.IntPtr new_ViewWrapper__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapper_Assign")] + public static extern global::System.IntPtr ViewWrapper_Assign(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapper_DownCast")] + public static extern global::System.IntPtr ViewWrapper_DownCast(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapperImpl_SWIGUpcast")] + public static extern global::System.IntPtr ViewWrapperImpl_SWIGUpcast(global::System.IntPtr jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapper_SWIGUpcast")] + public static extern global::System.IntPtr ViewWrapper_SWIGUpcast(global::System.IntPtr jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_RelayoutRequest")] + public static extern void ViewWrapperImpl_RelayoutRequest(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_GetHeightForWidthBase")] + public static extern float ViewWrapperImpl_GetHeightForWidthBase(global::System.Runtime.InteropServices.HandleRef jarg1, float jarg2); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_GetWidthForHeightBase")] + public static extern float ViewWrapperImpl_GetWidthForHeightBase(global::System.Runtime.InteropServices.HandleRef jarg1, float jarg2); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_CalculateChildSizeBase")] + public static extern float ViewWrapperImpl_CalculateChildSizeBase(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_0")] + public static extern bool ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_1")] + public static extern bool ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_RegisterVisual__SWIG_0")] + public static extern void ViewWrapperImpl_RegisterVisual__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_RegisterVisual__SWIG_1")] + public static extern void ViewWrapperImpl_RegisterVisual__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, bool jarg4); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_UnregisterVisual")] + public static extern void ViewWrapperImpl_UnregisterVisual(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_GetVisual")] + public static extern global::System.IntPtr ViewWrapperImpl_GetVisual(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_EnableVisual")] + public static extern void ViewWrapperImpl_EnableVisual(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, bool jarg3); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_IsVisualEnabled")] + public static extern bool ViewWrapperImpl_IsVisualEnabled(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_CreateTransition")] + public static extern global::System.IntPtr ViewWrapperImpl_CreateTransition(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ViewWrapperImpl_EmitKeyInputFocusSignal")] + public static extern void ViewWrapperImpl_EmitKeyInputFocusSignal(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapperImpl_ApplyThemeStyle")] + public static extern void ViewWrapperImpl_ApplyThemeStyle(global::System.Runtime.InteropServices.HandleRef jarg1); + } } diff --git a/plugins/dali-swig/manual/csharp/Tizen.Applications/DaliApplication.cs b/plugins/dali-swig/manual/csharp/Tizen.Applications/DaliApplication.cs index 6791355..59c9700 100644 --- a/plugins/dali-swig/manual/csharp/Tizen.Applications/DaliApplication.cs +++ b/plugins/dali-swig/manual/csharp/Tizen.Applications/DaliApplication.cs @@ -1,16 +1,24 @@ -// Copyright 2016 by Samsung Electronics, Inc., -// -// This software is the confidential and proprietary information -// of Samsung Electronics, Inc. ("Confidential Information"). You -// shall not disclose such Confidential Information and shall use -// it only in accordance with the terms of the license agreement -// you entered into with Samsung. +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + using System; using Dali; //------------------------------------------------------------------------------ -// -// // This file can only run on Tizen target. You should compile it with hello-test.cs, and // add tizen c# application related library as reference. //------------------------------------------------------------------------------ diff --git a/plugins/dali-swig/manual/csharp/ViewWrapper.cs b/plugins/dali-swig/manual/csharp/ViewWrapper.cs new file mode 100644 index 0000000..76281fa --- /dev/null +++ b/plugins/dali-swig/manual/csharp/ViewWrapper.cs @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +namespace Dali +{ + public class ViewWrapper : View + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected ViewWrapperImpl viewWrapperImpl; + + internal ViewWrapper(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.ViewWrapper_SWIGUpcast(cPtr), cMemoryOwn) + { + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ViewWrapper obj) + { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~ViewWrapper() + { + Dispose(); + } + + public override void Dispose() + { + lock(this) + { + if (swigCPtr.Handle != global::System.IntPtr.Zero) + { + if (swigCMemOwn) + { + swigCMemOwn = false; + NDalicManualPINVOKE.delete_ViewWrapper(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public ViewWrapper (ViewWrapperImpl implementation) : this (NDalicManualPINVOKE.ViewWrapper_New(ViewWrapperImpl.getCPtr(implementation)), true) + { + viewWrapperImpl = implementation; + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + } + + public ViewWrapper(ViewWrapper handle) : this(NDalicManualPINVOKE.new_ViewWrapper__SWIG_1(ViewWrapper.getCPtr(handle)), true) + { + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + } + + public ViewWrapper Assign(ViewWrapper handle) + { + ViewWrapper ret = new ViewWrapper(NDalicManualPINVOKE.ViewWrapper_Assign(swigCPtr, ViewWrapper.getCPtr(handle)), false); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public new static ViewWrapper DownCast(BaseHandle handle) + { + ViewWrapper ret = new ViewWrapper(NDalicManualPINVOKE.ViewWrapper_DownCast(BaseHandle.getCPtr(handle)), true); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } +} diff --git a/plugins/dali-swig/manual/csharp/ViewWrapperImpl.cs b/plugins/dali-swig/manual/csharp/ViewWrapperImpl.cs new file mode 100644 index 0000000..7605d4a --- /dev/null +++ b/plugins/dali-swig/manual/csharp/ViewWrapperImpl.cs @@ -0,0 +1,592 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +namespace Dali +{ + public sealed class ViewWrapperImpl : ViewImpl + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + public delegate void OnStageConnectionDelegate(int depth); + public delegate void OnStageDisconnectionDelegate(); + public delegate void OnChildAddDelegate(Actor actor); + public delegate void OnChildRemoveDelegate(Actor actor); + public delegate void OnPropertySetDelegate(int index, Property.Value propertyValue); + public delegate void OnSizeSetDelegate(Vector3 targetSize); + public delegate void OnSizeAnimationDelegate(Animation animation, Vector3 targetSize); + public delegate bool OnTouchEventDelegate(TouchEvent touchEvent); + public delegate bool OnHoverEventDelegate(HoverEvent hoverEvent); + public delegate bool OnKeyEventDelegate(KeyEvent keyEvent); + public delegate bool OnWheelEventDelegate(WheelEvent wheelEvent); + public delegate void OnRelayoutDelegate(Vector2 size, RelayoutContainer container); + public delegate void OnSetResizePolicyDelegate(ResizePolicyType policy, DimensionType dimension); + public delegate Vector3 GetNaturalSizeDelegate(); + public delegate float CalculateChildSizeDelegate(Actor child, DimensionType dimension); + public delegate float GetHeightForWidthDelegate(float width); + public delegate float GetWidthForHeightDelegate(float height); + public delegate bool RelayoutDependentOnChildrenDimensionDelegate(DimensionType dimension); + public delegate bool RelayoutDependentOnChildrenDelegate(); + public delegate void OnCalculateRelayoutSizeDelegate(DimensionType dimension); + public delegate void OnLayoutNegotiatedDelegate(float size, DimensionType dimension); + public delegate void OnControlChildAddDelegate(Actor child); + public delegate void OnControlChildRemoveDelegate(Actor child); + public delegate void OnStyleChangeDelegate(StyleManager styleManager, StyleChangeType change); + public delegate bool OnAccessibilityActivatedDelegate(); + public delegate bool OnAccessibilityPanDelegate(PanGesture gestures); + public delegate bool OnAccessibilityTouchDelegate(TouchEvent touchEvent); + public delegate bool OnAccessibilityValueChangeDelegate(bool isIncrease); + public delegate bool OnAccessibilityZoomDelegate(); + public delegate void OnKeyInputFocusGainedDelegate(); + public delegate void OnKeyInputFocusLostDelegate(); + public delegate Actor GetNextKeyboardFocusableActorDelegate(Actor currentFocusedActor, View.KeyboardFocus.Direction direction, bool loopEnabled); + public delegate void OnKeyboardFocusChangeCommittedDelegate(Actor commitedFocusableActor); + public delegate bool OnKeyboardEnterDelegate(); + public delegate void OnPinchDelegate(PinchGesture pinch); + public delegate void OnPanDelegate(PanGesture pan); + public delegate void OnTapDelegate(TapGesture tap); + public delegate void OnLongPressDelegate(LongPressGesture longPress); + public delegate void SignalConnectedDelegate(SlotObserver slotObserver, SWIGTYPE_p_Dali__CallbackBase callback); + public delegate void SignalDisconnectedDelegate(SlotObserver slotObserver, SWIGTYPE_p_Dali__CallbackBase callback); + + public OnStageConnectionDelegate OnStageConnection; + public OnStageDisconnectionDelegate OnStageDisconnection; + public OnChildAddDelegate OnChildAdd; + public OnChildRemoveDelegate OnChildRemove; + public OnPropertySetDelegate OnPropertySet; + public OnSizeSetDelegate OnSizeSet; + public OnSizeAnimationDelegate OnSizeAnimation; + public OnTouchEventDelegate OnTouchEvent; + public OnHoverEventDelegate OnHoverEvent; + public OnKeyEventDelegate OnKeyEvent; + public OnWheelEventDelegate OnWheelEvent; + public OnRelayoutDelegate OnRelayout; + public OnSetResizePolicyDelegate OnSetResizePolicy; + public GetNaturalSizeDelegate GetNaturalSize; + public CalculateChildSizeDelegate CalculateChildSize; + public GetHeightForWidthDelegate GetHeightForWidth; + public GetWidthForHeightDelegate GetWidthForHeight; + public RelayoutDependentOnChildrenDimensionDelegate RelayoutDependentOnChildrenDimension; + public RelayoutDependentOnChildrenDelegate RelayoutDependentOnChildren; + public OnCalculateRelayoutSizeDelegate OnCalculateRelayoutSize; + public OnLayoutNegotiatedDelegate OnLayoutNegotiated; + public OnControlChildAddDelegate OnControlChildAdd; + public OnControlChildRemoveDelegate OnControlChildRemove; + public OnStyleChangeDelegate OnStyleChange; + public OnAccessibilityActivatedDelegate OnAccessibilityActivated; + public OnAccessibilityPanDelegate OnAccessibilityPan; + public OnAccessibilityTouchDelegate OnAccessibilityTouch; + public OnAccessibilityValueChangeDelegate OnAccessibilityValueChange; + public OnAccessibilityZoomDelegate OnAccessibilityZoom; + public OnKeyInputFocusGainedDelegate OnKeyInputFocusGained; + public OnKeyInputFocusLostDelegate OnKeyInputFocusLost; + public GetNextKeyboardFocusableActorDelegate GetNextKeyboardFocusableActor; + public OnKeyboardFocusChangeCommittedDelegate OnKeyboardFocusChangeCommitted; + public OnKeyboardEnterDelegate OnKeyboardEnter; + public OnPinchDelegate OnPinch; + public OnPanDelegate OnPan; + public OnTapDelegate OnTap; + public OnLongPressDelegate OnLongPress; + public SignalConnectedDelegate SignalConnected; + public SignalDisconnectedDelegate SignalDisconnected; + + internal ViewWrapperImpl(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.ViewWrapperImpl_SWIGUpcast(cPtr), cMemoryOwn) + { + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ViewWrapperImpl obj) + { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~ViewWrapperImpl() + { + Dispose(); + } + + public override void Dispose() + { + lock(this) + { + if (swigCPtr.Handle != global::System.IntPtr.Zero) + { + if (swigCMemOwn) + { + swigCMemOwn = false; + NDalicManualPINVOKE.delete_ViewWrapperImpl(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public ViewWrapperImpl(ViewWrapperImpl.CustomViewBehaviour behaviourFlags) : this(NDalicManualPINVOKE.new_ViewWrapperImpl((int)behaviourFlags), true) + { + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + DirectorConnect(); + } + + public static ViewWrapper New(ViewWrapperImpl viewWrapper) + { + ViewWrapper ret = new ViewWrapper(NDalicManualPINVOKE.ViewWrapperImpl_New(ViewWrapperImpl.getCPtr(viewWrapper)), true); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void RelayoutRequest() + { + NDalicManualPINVOKE.ViewWrapperImpl_RelayoutRequest(swigCPtr); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + } + + public float GetHeightForWidthBase(float width) + { + float ret = NDalicManualPINVOKE.ViewWrapperImpl_GetHeightForWidthBase(swigCPtr, width); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public float GetWidthForHeightBase(float height) + { + float ret = NDalicManualPINVOKE.ViewWrapperImpl_GetWidthForHeightBase(swigCPtr, height); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public float CalculateChildSizeBase(Actor child, DimensionType dimension) + { + float ret = NDalicManualPINVOKE.ViewWrapperImpl_CalculateChildSizeBase(swigCPtr, Actor.getCPtr(child), (int)dimension); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool RelayoutDependentOnChildrenBase(DimensionType dimension) + { + bool ret = NDalicManualPINVOKE.ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_0(swigCPtr, (int)dimension); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool RelayoutDependentOnChildrenBase() + { + bool ret = NDalicManualPINVOKE.ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_1(swigCPtr); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void RegisterVisual(int index, VisualBase visual) + { + NDalicManualPINVOKE.ViewWrapperImpl_RegisterVisual__SWIG_0(swigCPtr, index, VisualBase.getCPtr(visual)); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RegisterVisual(int index, VisualBase visual, bool enabled) + { + NDalicManualPINVOKE.ViewWrapperImpl_RegisterVisual__SWIG_1(swigCPtr, index, VisualBase.getCPtr(visual), enabled); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + } + + public void UnregisterVisual(int index) + { + NDalicManualPINVOKE.ViewWrapperImpl_UnregisterVisual(swigCPtr, index); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + } + + public VisualBase GetVisual(int index) + { + VisualBase ret = new VisualBase(NDalicManualPINVOKE.ViewWrapperImpl_GetVisual(swigCPtr, index), true); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void EnableVisual(int index, bool enable) + { + NDalicManualPINVOKE.ViewWrapperImpl_EnableVisual(swigCPtr, index, enable); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool IsVisualEnabled(int index) + { + bool ret = NDalicManualPINVOKE.ViewWrapperImpl_IsVisualEnabled(swigCPtr, index); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public Animation CreateTransition(TransitionData transitionData) + { + Animation ret = new Animation(NDalicManualPINVOKE.ViewWrapperImpl_CreateTransition(swigCPtr, TransitionData.getCPtr(transitionData)), true); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void EmitKeyInputFocusSignal(bool focusGained) + { + NDalicManualPINVOKE.ViewWrapperImpl_EmitKeyInputFocusSignal(swigCPtr, focusGained); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + } + + public void ApplyThemeStyle() + { + NDalicManualPINVOKE.ViewWrapperImpl_ApplyThemeStyle(swigCPtr); + if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); + } + + private void DirectorConnect() + { + Delegate0 = new DelegateViewWrapperImpl_0(DirectorOnStageConnection); + Delegate1 = new DelegateViewWrapperImpl_1(DirectorOnStageDisconnection); + Delegate2 = new DelegateViewWrapperImpl_2(DirectorOnChildAdd); + Delegate3 = new DelegateViewWrapperImpl_3(DirectorOnChildRemove); + Delegate4 = new DelegateViewWrapperImpl_4(DirectorOnPropertySet); + Delegate5 = new DelegateViewWrapperImpl_5(DirectorOnSizeSet); + Delegate6 = new DelegateViewWrapperImpl_6(DirectorOnSizeAnimation); + Delegate7 = new DelegateViewWrapperImpl_7(DirectorOnTouchEvent); + Delegate8 = new DelegateViewWrapperImpl_8(DirectorOnHoverEvent); + Delegate9 = new DelegateViewWrapperImpl_9(DirectorOnKeyEvent); + Delegate10 = new DelegateViewWrapperImpl_10(DirectorOnWheelEvent); + Delegate11 = new DelegateViewWrapperImpl_11(DirectorOnRelayout); + Delegate12 = new DelegateViewWrapperImpl_12(DirectorOnSetResizePolicy); + Delegate13 = new DelegateViewWrapperImpl_13(DirectorGetNaturalSize); + Delegate14 = new DelegateViewWrapperImpl_14(DirectorCalculateChildSize); + Delegate15 = new DelegateViewWrapperImpl_15(DirectorGetHeightForWidth); + Delegate16 = new DelegateViewWrapperImpl_16(DirectorGetWidthForHeight); + Delegate17 = new DelegateViewWrapperImpl_17(DirectorRelayoutDependentOnChildren__SWIG_0); + Delegate18 = new DelegateViewWrapperImpl_18(DirectorRelayoutDependentOnChildren__SWIG_1); + Delegate19 = new DelegateViewWrapperImpl_19(DirectorOnCalculateRelayoutSize); + Delegate20 = new DelegateViewWrapperImpl_20(DirectorOnLayoutNegotiated); + Delegate21 = new DelegateViewWrapperImpl_21(DirectorOnInitialize); + Delegate22 = new DelegateViewWrapperImpl_22(DirectorOnControlChildAdd); + Delegate23 = new DelegateViewWrapperImpl_23(DirectorOnControlChildRemove); + Delegate24 = new DelegateViewWrapperImpl_24(DirectorOnStyleChange); + Delegate25 = new DelegateViewWrapperImpl_25(DirectorOnAccessibilityActivated); + Delegate26 = new DelegateViewWrapperImpl_26(DirectorOnAccessibilityPan); + Delegate27 = new DelegateViewWrapperImpl_27(DirectorOnAccessibilityTouch); + Delegate28 = new DelegateViewWrapperImpl_28(DirectorOnAccessibilityValueChange); + Delegate29 = new DelegateViewWrapperImpl_29(DirectorOnAccessibilityZoom); + Delegate30 = new DelegateViewWrapperImpl_30(DirectorOnKeyInputFocusGained); + Delegate31 = new DelegateViewWrapperImpl_31(DirectorOnKeyInputFocusLost); + Delegate32 = new DelegateViewWrapperImpl_32(DirectorGetNextKeyboardFocusableActor); + Delegate33 = new DelegateViewWrapperImpl_33(DirectorOnKeyboardFocusChangeCommitted); + Delegate34 = new DelegateViewWrapperImpl_34(DirectorOnKeyboardEnter); + Delegate35 = new DelegateViewWrapperImpl_35(DirectorOnPinch); + Delegate36 = new DelegateViewWrapperImpl_36(DirectorOnPan); + Delegate37 = new DelegateViewWrapperImpl_37(DirectorOnTap); + Delegate38 = new DelegateViewWrapperImpl_38(DirectorOnLongPress); + NDalicManualPINVOKE.ViewWrapperImpl_director_connect(swigCPtr, Delegate0, Delegate1, Delegate2, Delegate3, Delegate4, Delegate5, Delegate6, Delegate7, Delegate8, Delegate9, Delegate10, Delegate11, Delegate12, Delegate13, Delegate14, Delegate15, Delegate16, Delegate17, Delegate18, Delegate19, Delegate20, Delegate21, Delegate22, Delegate23, Delegate24, Delegate25, Delegate26, Delegate27, Delegate28, Delegate29, Delegate30, Delegate31, Delegate32, Delegate33, Delegate34, Delegate35, Delegate36, Delegate37, Delegate38, null, null); + } + + private void DirectorOnStageConnection(int depth) + { + OnStageConnection(depth); + } + + private void DirectorOnStageDisconnection() + { + OnStageDisconnection(); + } + + private void DirectorOnChildAdd(global::System.IntPtr child) + { + OnChildAdd(new Actor(child, false)); + } + + private void DirectorOnChildRemove(global::System.IntPtr child) + { + OnChildRemove(new Actor(child, false)); + } + + private void DirectorOnPropertySet(int index, global::System.IntPtr propertyValue) + { + OnPropertySet(index, new Property.Value(propertyValue, true)); + } + + private void DirectorOnSizeSet(global::System.IntPtr targetSize) + { + OnSizeSet(new Vector3(targetSize, false)); + } + + private void DirectorOnSizeAnimation(global::System.IntPtr animation, global::System.IntPtr targetSize) + { + OnSizeAnimation(new Animation(animation, false), new Vector3(targetSize, false)); + } + + private bool DirectorOnTouchEvent(global::System.IntPtr arg0) + { + return OnTouchEvent(new TouchEvent(arg0, false)); + } + + private bool DirectorOnHoverEvent(global::System.IntPtr arg0) + { + return OnHoverEvent(new HoverEvent(arg0, false)); + } + + private bool DirectorOnKeyEvent(global::System.IntPtr arg0) + { + return OnKeyEvent(new KeyEvent(arg0, false)); + } + + private bool DirectorOnWheelEvent(global::System.IntPtr arg0) + { + return OnWheelEvent(new WheelEvent(arg0, false)); + } + + private void DirectorOnRelayout(global::System.IntPtr size, global::System.IntPtr container) + { + OnRelayout(new Vector2(size, false), new RelayoutContainer(container, false)); + } + + private void DirectorOnSetResizePolicy(int policy, int dimension) + { + OnSetResizePolicy((ResizePolicyType)policy, (DimensionType)dimension); + } + + private global::System.IntPtr DirectorGetNaturalSize() + { + return Vector3.getCPtr(GetNaturalSize()).Handle; + } + + private float DirectorCalculateChildSize(global::System.IntPtr child, int dimension) + { + return CalculateChildSize(new Actor(child, false), (DimensionType)dimension); + } + + private float DirectorGetHeightForWidth(float width) + { + return GetHeightForWidth(width); + } + + private float DirectorGetWidthForHeight(float height) + { + return GetWidthForHeight(height); + } + + private bool DirectorRelayoutDependentOnChildren__SWIG_0(int dimension) + { + return RelayoutDependentOnChildrenDimension((DimensionType)dimension); + } + + private bool DirectorRelayoutDependentOnChildren__SWIG_1() + { + return RelayoutDependentOnChildren(); + } + + private void DirectorOnCalculateRelayoutSize(int dimension) + { + OnCalculateRelayoutSize((DimensionType)dimension); + } + + private void DirectorOnLayoutNegotiated(float size, int dimension) + { + OnLayoutNegotiated(size, (DimensionType)dimension); + } + + private void DirectorOnInitialize() + { + } + + private void DirectorOnControlChildAdd(global::System.IntPtr child) + { + OnControlChildAdd(new Actor(child, false)); + } + + private void DirectorOnControlChildRemove(global::System.IntPtr child) + { + OnControlChildRemove(new Actor(child, false)); + } + + private void DirectorOnStyleChange(global::System.IntPtr styleManager, int change) + { + OnStyleChange(new StyleManager(styleManager, false), (StyleChangeType)change); + } + + private bool DirectorOnAccessibilityActivated() + { + return OnAccessibilityActivated(); + } + + private bool DirectorOnAccessibilityPan(global::System.IntPtr gesture) + { + return OnAccessibilityPan(new PanGesture(gesture, false)); + } + + private bool DirectorOnAccessibilityTouch(global::System.IntPtr touchEvent) + { + return OnAccessibilityTouch(new TouchEvent(touchEvent, false)); + } + + private bool DirectorOnAccessibilityValueChange(bool isIncrease) + { + return OnAccessibilityValueChange(isIncrease); + } + + private bool DirectorOnAccessibilityZoom() + { + return OnAccessibilityZoom(); + } + + private void DirectorOnKeyInputFocusGained() + { + OnKeyInputFocusGained(); + } + + private void DirectorOnKeyInputFocusLost() + { + OnKeyInputFocusLost(); + } + + private global::System.IntPtr DirectorGetNextKeyboardFocusableActor(global::System.IntPtr currentFocusedActor, int direction, bool loopEnabled) + { + return Actor.getCPtr(GetNextKeyboardFocusableActor(new Actor(currentFocusedActor, false), (View.KeyboardFocus.Direction)direction, loopEnabled)).Handle; + } + + private void DirectorOnKeyboardFocusChangeCommitted(global::System.IntPtr commitedFocusableActor) + { + OnKeyboardFocusChangeCommitted(new Actor(commitedFocusableActor, false)); + } + + private bool DirectorOnKeyboardEnter() + { + return OnKeyboardEnter(); + } + + private void DirectorOnPinch(global::System.IntPtr pinch) + { + OnPinch(new PinchGesture(pinch, false)); + } + + private void DirectorOnPan(global::System.IntPtr pan) + { + OnPan(new PanGesture(pan, false)); + } + + private void DirectorOnTap(global::System.IntPtr tap) + { + OnTap(new TapGesture(tap, false)); + } + + private void DirectorOnLongPress(global::System.IntPtr longPress) + { + OnLongPress(new LongPressGesture(longPress, false)); + } + + private void DirectorSignalConnected(global::System.IntPtr slotObserver, global::System.IntPtr callback) + { + SignalConnected((slotObserver == global::System.IntPtr.Zero) ? null : new SlotObserver(slotObserver, false), (callback == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_Dali__CallbackBase(callback, false)); + } + + private void DirectorSignalDisconnected(global::System.IntPtr slotObserver, global::System.IntPtr callback) + { + SignalDisconnected((slotObserver == global::System.IntPtr.Zero) ? null : new SlotObserver(slotObserver, false), (callback == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_Dali__CallbackBase(callback, false)); + } + + public delegate void DelegateViewWrapperImpl_0(int depth); + public delegate void DelegateViewWrapperImpl_1(); + public delegate void DelegateViewWrapperImpl_2(global::System.IntPtr child); + public delegate void DelegateViewWrapperImpl_3(global::System.IntPtr child); + public delegate void DelegateViewWrapperImpl_4(int index, global::System.IntPtr propertyValue); + public delegate void DelegateViewWrapperImpl_5(global::System.IntPtr targetSize); + public delegate void DelegateViewWrapperImpl_6(global::System.IntPtr animation, global::System.IntPtr targetSize); + public delegate bool DelegateViewWrapperImpl_7(global::System.IntPtr arg0); + public delegate bool DelegateViewWrapperImpl_8(global::System.IntPtr arg0); + public delegate bool DelegateViewWrapperImpl_9(global::System.IntPtr arg0); + public delegate bool DelegateViewWrapperImpl_10(global::System.IntPtr arg0); + public delegate void DelegateViewWrapperImpl_11(global::System.IntPtr size, global::System.IntPtr container); + public delegate void DelegateViewWrapperImpl_12(int policy, int dimension); + public delegate global::System.IntPtr DelegateViewWrapperImpl_13(); + public delegate float DelegateViewWrapperImpl_14(global::System.IntPtr child, int dimension); + public delegate float DelegateViewWrapperImpl_15(float width); + public delegate float DelegateViewWrapperImpl_16(float height); + public delegate bool DelegateViewWrapperImpl_17(int dimension); + public delegate bool DelegateViewWrapperImpl_18(); + public delegate void DelegateViewWrapperImpl_19(int dimension); + public delegate void DelegateViewWrapperImpl_20(float size, int dimension); + public delegate void DelegateViewWrapperImpl_21(); + public delegate void DelegateViewWrapperImpl_22(global::System.IntPtr child); + public delegate void DelegateViewWrapperImpl_23(global::System.IntPtr child); + public delegate void DelegateViewWrapperImpl_24(global::System.IntPtr styleManager, int change); + public delegate bool DelegateViewWrapperImpl_25(); + public delegate bool DelegateViewWrapperImpl_26(global::System.IntPtr gesture); + public delegate bool DelegateViewWrapperImpl_27(global::System.IntPtr touchEvent); + public delegate bool DelegateViewWrapperImpl_28(bool isIncrease); + public delegate bool DelegateViewWrapperImpl_29(); + public delegate void DelegateViewWrapperImpl_30(); + public delegate void DelegateViewWrapperImpl_31(); + public delegate global::System.IntPtr DelegateViewWrapperImpl_32(global::System.IntPtr currentFocusedActor, int direction, bool loopEnabled); + public delegate void DelegateViewWrapperImpl_33(global::System.IntPtr commitedFocusableActor); + public delegate bool DelegateViewWrapperImpl_34(); + public delegate void DelegateViewWrapperImpl_35(global::System.IntPtr pinch); + public delegate void DelegateViewWrapperImpl_36(global::System.IntPtr pan); + public delegate void DelegateViewWrapperImpl_37(global::System.IntPtr tap); + public delegate void DelegateViewWrapperImpl_38(global::System.IntPtr longPress); + public delegate void DelegateViewWrapperImpl_39(global::System.IntPtr slotObserver, global::System.IntPtr callback); + public delegate void DelegateViewWrapperImpl_40(global::System.IntPtr slotObserver, global::System.IntPtr callback); + + private DelegateViewWrapperImpl_0 Delegate0; + private DelegateViewWrapperImpl_1 Delegate1; + private DelegateViewWrapperImpl_2 Delegate2; + private DelegateViewWrapperImpl_3 Delegate3; + private DelegateViewWrapperImpl_4 Delegate4; + private DelegateViewWrapperImpl_5 Delegate5; + private DelegateViewWrapperImpl_6 Delegate6; + private DelegateViewWrapperImpl_7 Delegate7; + private DelegateViewWrapperImpl_8 Delegate8; + private DelegateViewWrapperImpl_9 Delegate9; + private DelegateViewWrapperImpl_10 Delegate10; + private DelegateViewWrapperImpl_11 Delegate11; + private DelegateViewWrapperImpl_12 Delegate12; + private DelegateViewWrapperImpl_13 Delegate13; + private DelegateViewWrapperImpl_14 Delegate14; + private DelegateViewWrapperImpl_15 Delegate15; + private DelegateViewWrapperImpl_16 Delegate16; + private DelegateViewWrapperImpl_17 Delegate17; + private DelegateViewWrapperImpl_18 Delegate18; + private DelegateViewWrapperImpl_19 Delegate19; + private DelegateViewWrapperImpl_20 Delegate20; + private DelegateViewWrapperImpl_21 Delegate21; + private DelegateViewWrapperImpl_22 Delegate22; + private DelegateViewWrapperImpl_23 Delegate23; + private DelegateViewWrapperImpl_24 Delegate24; + private DelegateViewWrapperImpl_25 Delegate25; + private DelegateViewWrapperImpl_26 Delegate26; + private DelegateViewWrapperImpl_27 Delegate27; + private DelegateViewWrapperImpl_28 Delegate28; + private DelegateViewWrapperImpl_29 Delegate29; + private DelegateViewWrapperImpl_30 Delegate30; + private DelegateViewWrapperImpl_31 Delegate31; + private DelegateViewWrapperImpl_32 Delegate32; + private DelegateViewWrapperImpl_33 Delegate33; + private DelegateViewWrapperImpl_34 Delegate34; + private DelegateViewWrapperImpl_35 Delegate35; + private DelegateViewWrapperImpl_36 Delegate36; + private DelegateViewWrapperImpl_37 Delegate37; + private DelegateViewWrapperImpl_38 Delegate38; + private DelegateViewWrapperImpl_39 Delegate39; + private DelegateViewWrapperImpl_40 Delegate40; + + public enum CustomViewBehaviour + { + VIEW_BEHAVIOUR_DEFAULT = 0, + DISABLE_SIZE_NEGOTIATION = 1 << 0, + REQUIRES_KEYBOARD_NAVIGATION_SUPPORT = 1 << 5, + DISABLE_STYLE_CHANGE_SIGNALS = 1 << 6, + LAST_VIEW_BEHAVIOUR_FLAG + } + + public static readonly int VIEW_BEHAVIOUR_FLAG_COUNT = NDalicManualPINVOKE.ViewWrapperImpl_CONTROL_BEHAVIOUR_FLAG_COUNT_get(); + } +}