--- /dev/null
+
+Copyright (c) 2017 Samsung Electronics Co, Ltd. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <cstdio>
#include <iostream>
#include <cstring>
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/dali-core.h>
#define TOKENPASTE(x,y) x y
#define TOKENPASTE2(x,y) TOKENPASTE( x, y )
#define TEST_LOCATION TOKENPASTE2( "Test failed in ", TOKENPASTE2( __FILE__, TOKENPASTE2( ", line ", STRINGIZE(__LINE__) ) ) )
+#define TEST_INNER_LOCATION(x) ( std::string(x) + " (" + STRINGIZE(__LINE__) + ")" ).c_str()
#define TET_UNDEF 2
#define TET_FAIL 1
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali.h>
#include <dali/public-api/rendering/renderer.h>
+#include <dali/devel-api/object/handle-devel.h>
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/devel-api/controls/bubble-effect/bubble-emitter.h>
(bubbleRenderer.GetProperty(propertyIndex1)).Get( value1 );
DALI_TEST_EQUALS(value0, 0.f, TEST_LOCATION );
DALI_TEST_EQUALS(value1, 0.f, TEST_LOCATION );
+ ( DevelHandle::GetCurrentProperty( bubbleRenderer, propertyIndex0 ) ).Get( value0 );
+ ( DevelHandle::GetCurrentProperty( bubbleRenderer, propertyIndex0 ) ).Get( value1 );
+ DALI_TEST_EQUALS(value0, 0.f, TEST_LOCATION );
+ DALI_TEST_EQUALS(value1, 0.f, TEST_LOCATION );
animation.Play();
Wait(application, 300);
propertyIndex0 = bubbleRenderer.GetPropertyIndex( "uPercentage[0]" );
propertyIndex1 = bubbleRenderer.GetPropertyIndex( "uPercentage[1]" );
- (bubbleRenderer.GetProperty(propertyIndex0)).Get( value0 );
- (bubbleRenderer.GetProperty(propertyIndex1)).Get( value1 );
+ ( DevelHandle::GetCurrentProperty( bubbleRenderer, propertyIndex0 ) ).Get( value0 );
+ ( DevelHandle::GetCurrentProperty( bubbleRenderer, propertyIndex0 ) ).Get( value1 );
DALI_TEST_CHECK( value0 >= 0.6f );
DALI_TEST_CHECK( value1 >= 0.6f );
Wait(application,500);
- (bubbleRenderer.GetProperty(propertyIndex0)).Get( value0 );
- (bubbleRenderer.GetProperty(propertyIndex1)).Get( value1 );
+ ( DevelHandle::GetCurrentProperty( bubbleRenderer, propertyIndex0 ) ).Get( value0 );
+ ( DevelHandle::GetCurrentProperty( bubbleRenderer, propertyIndex0 ) ).Get( value1 );
DALI_TEST_EQUALS(value0, 1.f, TEST_LOCATION );
DALI_TEST_EQUALS(value1, 1.f, TEST_LOCATION );
END_TEST;
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <iostream>
#include <stdlib.h>
#include <sstream>
+#include <dali/devel-api/object/handle-devel.h>
#include <dali-toolkit-test-suite-utils.h>
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/devel-api/controls/effects-view/effects-view.h>
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
- value = view.GetProperty( EffectsView::Property::EFFECT_OFFSET );
+ value = DevelHandle::GetCurrentProperty( view, EffectsView::Property::EFFECT_OFFSET );
value.Get(offsetValue);
DALI_TEST_EQUALS( offsetValue, offsetAnimate, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
- value = view.GetProperty( EffectsView::Property::EFFECT_COLOR );
+ value = DevelHandle::GetCurrentProperty( view, EffectsView::Property::EFFECT_COLOR );
value.Get(colorValue);
DALI_TEST_EQUALS( colorValue, colorAnimate, TEST_LOCATION );
manager.SetFocus( dummy3 );
DALI_TEST_CHECK( dummy3Impl.keyInputFocusGained );
- Integration::KeyEvent event("a", "a", 0, 0, 0, Integration::KeyEvent::Up, "");
+ Integration::KeyEvent event( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, "", DevelKeyEvent::DeviceClass::TOUCH );
application.ProcessEvent(event);
DALI_TEST_CHECK( callback1.mIsCalled );
manager.SetFocus( dummy3 );
DALI_TEST_CHECK( dummy3Impl.keyInputFocusGained );
- Integration::KeyEvent event("a", "a", 0, 0, 0, Integration::KeyEvent::Up, "" );
+ Integration::KeyEvent event( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, "", DevelKeyEvent::DeviceClass::TOUCH );
application.ProcessEvent(event);
DALI_TEST_CHECK( !callback1.mIsCalled );
const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
-
// Functors to test whether GetNextFocusableActor() method of CustomAlgorithmInterface is called when the keyboard focus is about to change
class CustomAlgorithm : public Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface
{
FocusedActorActivatedCallback focusedActorActivatedCallback(focusedActorActivatedSignalVerified);
manager.FocusedActorEnterKeySignal().Connect( &focusedActorActivatedCallback, &FocusedActorActivatedCallback::Callback );
- Integration::KeyEvent returnEvent("Return", "", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME );
+ Integration::KeyEvent returnEvent( "Return", "", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE );
// Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
// It makes mIsFocusIndicatorEnabled true
FocusGroupChangedCallback focusGroupChangedCallback(focusGroupChangedSignalVerified);
manager.FocusGroupChangedSignal().Connect( &focusGroupChangedCallback, &FocusGroupChangedCallback::Callback );
- Integration::KeyEvent tabEvent("Tab", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
- Integration::KeyEvent shiftTabEvent("Tab", "", 0, 1, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME);
+ Integration::KeyEvent tabEvent( "Tab", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE );
+ Integration::KeyEvent shiftTabEvent( "Tab", "", 0, 1, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE );
// Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
// It makes mIsFocusIndicatorEnabled true
FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
- Integration::KeyEvent leftEvent("Left", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME);
- Integration::KeyEvent rightEvent("Right", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
- Integration::KeyEvent upEvent("Up", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
- Integration::KeyEvent downEvent("Down", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
- Integration::KeyEvent pageUpEvent("Prior", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
- Integration::KeyEvent pageDownEvent("Next", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
+ Integration::KeyEvent leftEvent( "Left", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE );
+ Integration::KeyEvent rightEvent( "Right", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE );
+ Integration::KeyEvent upEvent( "Up", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE );
+ Integration::KeyEvent downEvent( "Down", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE );
+ Integration::KeyEvent pageUpEvent( "Prior", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE );
+ Integration::KeyEvent pageDownEvent( "Next", "", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE );
// Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
// It makes mIsFocusIndicatorEnabled true
int keyModifier,
unsigned long timeStamp,
const Integration::KeyEvent::State& keyState,
- const std::string& deviceName
+ const std::string& deviceName,
+ const DevelKeyEvent::DeviceClass::Type& deviceClass
)
{
return Integration::KeyEvent( keyName,
keyModifier,
timeStamp,
keyState,
- deviceName);
+ deviceName,
+ deviceClass );
}
} // Anonymous namespace
popup.SetKeyInputFocus();
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::Down, "" ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::Down, "", DevelKeyEvent::DeviceClass::TOUCH ) );
application.SendNotification();
application.Render();
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <iostream>
#include <stdlib.h>
#include <dali-toolkit-test-suite-utils.h>
+#include <dali/devel-api/object/handle-devel.h>
#include <dali-toolkit/dali-toolkit.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/events/pan-gesture-event.h>
int timeToReachOrigin = -1;
for(int i = 0;i<MAX_FRAMES_TO_TEST_OVERSHOOT;i++)
{
- float overshootXValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_X);
- float overshootYValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_Y);
+ float overshootXValue = DevelHandle::GetCurrentProperty<float>( scrollView, ScrollView::Property::OVERSHOOT_X );
+ float overshootYValue = DevelHandle::GetCurrentProperty<float>( scrollView, ScrollView::Property::OVERSHOOT_Y );
if(overshootXValue == 0.0f && overshootYValue == 0.0f)
{
break;
// 1. Scroll page in NW (-500,-500 pixels), then inspect overshoot. (don't release touch)
Vector2 currentPos = Vector2(100.0f, 100.0f);
currentPos = PerformGestureDiagonalSwipe(application, currentPos, Vector2(5.0f, 5.0f), 100, false);
- float overshootXValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_X);
- float overshootYValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_Y);
- Vector2 positionValue = scrollView.GetProperty<Vector2>(ScrollView::Property::SCROLL_POSITION);
+ float overshootXValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_X );
+ float overshootYValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_Y );
+ Vector2 positionValue = DevelHandle::GetCurrentProperty< Vector2 >( scrollView, ScrollView::Property::SCROLL_POSITION );
DALI_TEST_EQUALS(overshootXValue, 1.0f, TEST_LOCATION);
DALI_TEST_EQUALS(overshootYValue, 1.0f, TEST_LOCATION);
DALI_TEST_EQUALS(positionValue, Vector2::ZERO, TEST_LOCATION);
// Scroll page in NW (-20,-20 pixels), then check that overshoot should be 0. (don't release touch)
Vector2 currentPos = PerformGestureDiagonalSwipe(application, OVERSHOOT_START_SCROLL_POSITION, Vector2(1.0f, 1.0f), 20, false);
- float overshootXValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_X);
- float overshootYValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_Y);
+ float overshootXValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_X );
+ float overshootYValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_Y );
DALI_TEST_EQUALS(overshootXValue, 0.0f, TEST_LOCATION);
DALI_TEST_EQUALS(overshootYValue, 0.0f, TEST_LOCATION);
// Scroll page further in NW (-105,-105 pixels), then check that overshoot should be around 0.5. (don't release touch)
currentPos = PerformGestureDiagonalSwipe(application, OVERSHOOT_START_SCROLL_POSITION, Vector2(1.0f, 1.0f), 105, false);
- overshootXValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_X);
- overshootYValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_Y);
+ overshootXValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_X );
+ overshootYValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_Y );
// The overshoot value is a 0.0f - 1.0f ranged value of the amount overshot related to the maximum overshoot.
// EG. If we move 105, max overshoot is 50, then we overshot 50 / 105.
float correctOvershootValue = 50.0f / 105.f;
// Scroll page further in NW (-30,-30 pixels), then check that overshoot should be now 1.0. (don't release touch)
currentPos = PerformGestureDiagonalSwipe(application, OVERSHOOT_START_SCROLL_POSITION, Vector2(1.0f, 1.0f), 30, false);
- overshootXValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_X);
- overshootYValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_Y);
+ overshootXValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_X );
+ overshootYValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_Y );
DALI_TEST_EQUALS(overshootXValue, 1.0f, TEST_LOCATION);
DALI_TEST_EQUALS(overshootYValue, 1.0f, TEST_LOCATION);
Wait(application);
// Check that overshoot should be now around 0.8.
- overshootXValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_X);
- overshootYValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_Y);
+ overshootXValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_X );
+ overshootYValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_Y );
DALI_TEST_CHECK(overshootXValue > 0.79f && overshootXValue < 0.81f);
DALI_TEST_CHECK(overshootYValue > 0.79f && overshootYValue < 0.81f);
// Scroll page further in NW (-30,-30 pixels), then check that overshoot should be now 1.0. (don't release touch)
currentPos = PerformGestureDiagonalSwipe(application, OVERSHOOT_START_SCROLL_POSITION, Vector2(1.0f, 1.0f), 30, false);
- overshootXValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_X);
- overshootYValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_Y);
+ overshootXValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_X );
+ overshootYValue = DevelHandle::GetCurrentProperty< float >( scrollView, ScrollView::Property::OVERSHOOT_Y );
DALI_TEST_EQUALS(overshootXValue, 1.0f, TEST_LOCATION);
DALI_TEST_EQUALS(overshootYValue, 1.0f, TEST_LOCATION);
const char* const PROPERTY_NAME_ENABLE_SCROLL_BAR = "enableScrollBar";
const char* const PROPERTY_NAME_SCROLL_BAR_SHOW_DURATION = "scrollBarShowDuration";
const char* const PROPERTY_NAME_SCROLL_BAR_FADE_DURATION = "scrollBarFadeDuration";
+const char* const PROPERTY_NAME_PIXEL_SIZE = "pixelSize";
const int DEFAULT_RENDERING_BACKEND = Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
int keyModifier,
unsigned long timeStamp,
const Integration::KeyEvent::State& keyState,
- const std::string& deviceName )
+ const std::string& deviceName,
+ const DevelKeyEvent::DeviceClass::Type& deviceClass )
{
return Integration::KeyEvent( keyName,
keyString,
keyModifier,
timeStamp,
keyState,
- deviceName );
+ deviceName,
+ deviceClass );
}
/**
DALI_TEST_CHECK( editor.GetPropertyIndex( PROPERTY_NAME_ENABLE_SCROLL_BAR ) == DevelTextEditor::Property::ENABLE_SCROLL_BAR );
DALI_TEST_CHECK( editor.GetPropertyIndex( PROPERTY_NAME_SCROLL_BAR_SHOW_DURATION ) == DevelTextEditor::Property::SCROLL_BAR_SHOW_DURATION );
DALI_TEST_CHECK( editor.GetPropertyIndex( PROPERTY_NAME_SCROLL_BAR_FADE_DURATION ) == DevelTextEditor::Property::SCROLL_BAR_FADE_DURATION );
+ DALI_TEST_CHECK( editor.GetPropertyIndex( PROPERTY_NAME_PIXEL_SIZE ) == DevelTextEditor::Property::PIXEL_SIZE );
END_TEST;
}
editor.SetProperty( DevelTextEditor::Property::SCROLL_BAR_FADE_DURATION, 0.2f );
DALI_TEST_EQUALS( editor.GetProperty<float>( DevelTextEditor::Property::SCROLL_BAR_FADE_DURATION ), 0.2f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ // Check the pixel size of font
+ editor.SetProperty( DevelTextEditor::Property::PIXEL_SIZE, 20.f );
+ DALI_TEST_EQUALS( editor.GetProperty<float>( DevelTextEditor::Property::PIXEL_SIZE ), 20.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+
END_TEST;
}
editor.SetKeyInputFocus();
gTextChangedCallBackCalled = false;
- application.ProcessEvent( GenerateKey( "D", "D", KEY_D_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "D", "D", KEY_D_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
DALI_TEST_CHECK( gTextChangedCallBackCalled );
END_TEST;
gInputStyleMask = TextEditor::InputStyle::NONE;
inputStyleChangedSignal = false;
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
gInputStyleMask = TextEditor::InputStyle::NONE;
inputStyleChangedSignal = false;
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
gInputStyleMask = TextEditor::InputStyle::NONE;
inputStyleChangedSignal = false;
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
editor.SetProperty( TextEditor::Property::INPUT_EMBOSS, "emboss" );
editor.SetProperty( TextEditor::Property::INPUT_OUTLINE, "outline" );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
application.Render();
// Add a key event but as the text editor has not the focus it should do nothing.
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
application.Render();
// Now the text editor has the focus, so it can handle the key events.
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
application.Render();
// The second text editor has the focus. It should handle the key events.
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
DALI_TEST_EQUALS( stencil.GetChildCount(), 0u, TEST_LOCATION );
// Now the text editor has the focus, so it can handle the key events.
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
// Move the cursor and check the position changes.
Vector3 position1 = cursor.GetCurrentPosition();
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
DALI_TEST_CHECK( position2.x < position1.x );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
DALI_TEST_CHECK( position5.x > position4.x );
// Remove all the text.
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
editor.SetProperty( TextEditor::Property::TEXT, "" );
// Render and notify
application.Render();
// Move at the end of the text.
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
for( unsigned int index = 0u; index < 10u; ++index )
{
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
}
// Add a character
- application.ProcessEvent( GenerateKey( "d", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "d", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
DALI_TEST_EQUALS( "Hello\nworld", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
// Add some key events
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_UP, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_UP, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_UP, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_UP, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
for( unsigned int index = 0u; index < 10u; ++index )
{
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
}
// Add a character
- application.ProcessEvent( GenerateKey( " ", " ", KEY_WHITE_SPACE_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( " ", " ", KEY_WHITE_SPACE_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
application.Render();
// Move at the end of the text.
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
for( unsigned int index = 0u; index < 10u; ++index )
{
// Add a character
- application.ProcessEvent( GenerateKey( "d", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "d", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
// Continuous scroll left to increase coverage
for( unsigned int index = 0u; index < 10u; ++index )
{
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
DALI_TEST_EQUALS( editor.GetProperty<float>( DevelTextEditor::Property::SCROLL_BAR_FADE_DURATION ), 0.2f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
// Press Escape to increase coverage
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
application.SendNotification();
application.Render();
const char* const PROPERTY_NAME_INPUT_OUTLINE = "inputOutline";
const char* const PROPERTY_NAME_HIDDEN_INPUT_SETTINGS = "hiddenInputSettings";
+const char* const PROPERTY_NAME_PIXEL_SIZE = "pixelSize";
const int DEFAULT_RENDERING_BACKEND = Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
int keyModifier,
unsigned long timeStamp,
const Integration::KeyEvent::State& keyState,
- const std::string& deviceName )
+ const std::string& deviceName,
+ const DevelKeyEvent::DeviceClass::Type& deviceClass )
{
return Integration::KeyEvent( keyName,
keyString,
keyModifier,
timeStamp,
keyState,
- deviceName );
+ deviceName,
+ deviceClass );
}
bool DaliTestCheckMaps( const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet )
DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_OUTLINE ) == TextField::Property::OUTLINE );
DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_OUTLINE ) == TextField::Property::INPUT_OUTLINE );
DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_HIDDEN_INPUT_SETTINGS ) == DevelTextField::Property::HIDDEN_INPUT_SETTINGS );
+ DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_PIXEL_SIZE ) == DevelTextField::Property::PIXEL_SIZE );
END_TEST;
}
DALI_TEST_EQUALS( hiddenMapSet.Count(), hiddenMapGet.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( DaliTestCheckMaps( hiddenMapSet, hiddenMapGet ), true, TEST_LOCATION );
+ // Check the pixel size of font
+ field.SetProperty( DevelTextField::Property::PIXEL_SIZE, 20.f );
+ DALI_TEST_EQUALS( field.GetProperty<float>( DevelTextField::Property::PIXEL_SIZE ), 20.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+
END_TEST;
}
field.SetKeyInputFocus();
gTextChangedCallBackCalled = false;
- application.ProcessEvent( GenerateKey( "D", "D", KEY_D_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "D", "D", KEY_D_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
DALI_TEST_CHECK( gTextChangedCallBackCalled );
END_TEST;
gMaxCharactersCallBackCalled = false;
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
DALI_TEST_CHECK( gMaxCharactersCallBackCalled );
DALI_TEST_CHECK( maxLengthReachedSignal );
gMaxCharactersCallBackCalled = false;
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
DALI_TEST_CHECK( !gMaxCharactersCallBackCalled );
DALI_TEST_CHECK( !maxLengthReachedSignal );
gInputStyleMask = TextField::InputStyle::NONE;
inputStyleChangedSignal = false;
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
gInputStyleMask = TextField::InputStyle::NONE;
inputStyleChangedSignal = false;
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
gInputStyleMask = TextField::InputStyle::NONE;
inputStyleChangedSignal = false;
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
application.Render();
// Add a key event but as the text field has not the focus it should do nothing.
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
application.Render();
// Now the text field has the focus, so it can handle the key events.
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
application.Render();
// The second text field has the focus. It should handle the key events.
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
DALI_TEST_EQUALS( stencil.GetChildCount(), 0u, TEST_LOCATION );
// Now the text field has the focus, so it can handle the key events.
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
// Move the cursor and check the position changes.
Vector3 position1 = cursor.GetCurrentPosition();
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
DALI_TEST_CHECK( position2.x < position1.x );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
DALI_TEST_CHECK( position5.x > position4.x );
// Remove all the text.
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
field.SetProperty( TextField::Property::TEXT, "" );
// Render and notify
Property::Map map;
map[ HiddenInput::Property::MODE ] = HiddenInput::Mode::HIDE_NONE;
field.SetProperty( DevelTextField::Property::HIDDEN_INPUT_SETTINGS, map );
- application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
application.SendNotification();
application.Render();
map[ HiddenInput::Property::MODE ] = HiddenInput::Mode::HIDE_ALL;
map[ HiddenInput::Property::SUBSTITUTE_CHARACTER ] = 0x23;
field.SetProperty( DevelTextField::Property::HIDDEN_INPUT_SETTINGS, map );
- application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
application.SendNotification();
application.Render();
field.SetProperty( DevelTextField::Property::HIDDEN_INPUT_SETTINGS, map );
for( unsigned int index = 0u; index < 5u; ++index )
{
- application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
application.SendNotification();
application.Render();
}
field.SetProperty( DevelTextField::Property::HIDDEN_INPUT_SETTINGS, map );
for( unsigned int index = 0u; index < 5u; ++index )
{
- application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
application.SendNotification();
application.Render();
}
map[ HiddenInput::Property::MODE ] = HiddenInput::Mode::SHOW_LAST_CHARACTER;
map[ HiddenInput::Property::SHOW_DURATION ] = 0;
field.SetProperty( DevelTextField::Property::HIDDEN_INPUT_SETTINGS, map );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
application.SendNotification();
application.Render();
- application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
application.SendNotification();
application.Render();
map[ HiddenInput::Property::SHOW_DURATION ] = 100;
field.SetProperty( DevelTextField::Property::HIDDEN_INPUT_SETTINGS, map );
- application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "d", "d", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
application.SendNotification();
application.Render();
DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
// Press Escape to increase coverage
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
application.SendNotification();
application.Render();
application.Render();
// Add a key event but as the text field has not the focus it should do nothing.
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
application.Render();
// Now the text field has the focus, so it can handle the key events.
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "d", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "d", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "d", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "d", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("ad"), TEST_LOCATION );
// Generate a Esc key event. The text field should lose the focus.
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
DALI_TEST_EQUALS( false, field.HasKeyInputFocus(), TEST_LOCATION );
// No more text should be introduced
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
application.Render();
// Generate a Esc key event. The text field should lose the focus.
- application.ProcessEvent( GenerateKey( "XF86PowerOff", "XF86PowerOff", DALI_KEY_POWER, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "XF86PowerOff", "XF86PowerOff", DALI_KEY_POWER, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "XF86PowerOff", "XF86PowerOff", DALI_KEY_POWER, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "XF86PowerOff", "XF86PowerOff", DALI_KEY_POWER, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
application.Render();
// Generate a Esc key event. The text field should lose the focus.
- application.ProcessEvent( GenerateKey( "XF86Menu", "XF86Menu", DALI_KEY_MENU, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "XF86Menu", "XF86Menu", DALI_KEY_MENU, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "XF86Menu", "XF86Menu", DALI_KEY_MENU, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "XF86Menu", "XF86Menu", DALI_KEY_MENU, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
application.Render();
// Generate a Esc key event. The text field should lose the focus.
- application.ProcessEvent( GenerateKey( "XF86Home", "XF86Home", DALI_KEY_HOME, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ) );
- application.ProcessEvent( GenerateKey( "XF86Home", "XF86Home", DALI_KEY_HOME, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ) );
+ application.ProcessEvent( GenerateKey( "XF86Home", "XF86Home", DALI_KEY_HOME, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
+ application.ProcessEvent( GenerateKey( "XF86Home", "XF86Home", DALI_KEY_HOME, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DevelKeyEvent::DeviceClass::NONE ) );
// Render and notify
application.SendNotification();
#include <dali-toolkit-test-suite-utils.h>
#include <dali-toolkit/dali-toolkit.h>
+#include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
using namespace Dali;
using namespace Toolkit;
const char* const PROPERTY_NAME_EMBOSS = "emboss";
const char* const PROPERTY_NAME_OUTLINE = "outline";
+const char* const PROPERTY_NAME_PIXEL_SIZE = "pixelSize";
+const char* const PROPERTY_NAME_ELLIPSIS = "ellipsis";
+
const int DEFAULT_RENDERING_BACKEND = Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
const std::string DEFAULT_FONT_DIR( "/resources/fonts" );
const unsigned int EMOJI_FONT_SIZE = 3840u; // 60 * 64
DALI_TEST_CHECK( label.GetPropertyIndex( PROPERTY_NAME_SHADOW ) == TextLabel::Property::SHADOW );
DALI_TEST_CHECK( label.GetPropertyIndex( PROPERTY_NAME_EMBOSS ) == TextLabel::Property::EMBOSS );
DALI_TEST_CHECK( label.GetPropertyIndex( PROPERTY_NAME_OUTLINE ) == TextLabel::Property::OUTLINE );
+ DALI_TEST_CHECK( label.GetPropertyIndex( PROPERTY_NAME_PIXEL_SIZE ) == DevelTextLabel::Property::PIXEL_SIZE );
+ DALI_TEST_CHECK( label.GetPropertyIndex( PROPERTY_NAME_ELLIPSIS ) == DevelTextLabel::Property::ELLIPSIS );
END_TEST;
}
label.SetProperty( TextLabel::Property::OUTLINE, "Outline properties" );
DALI_TEST_EQUALS( label.GetProperty<std::string>( TextLabel::Property::OUTLINE ), std::string("Outline properties"), TEST_LOCATION );
+ // Check the pixel size of font
+ label.SetProperty( DevelTextLabel::Property::PIXEL_SIZE, 20.f );
+ DALI_TEST_EQUALS( label.GetProperty<float>( DevelTextLabel::Property::PIXEL_SIZE ), 20.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+
+ // Check the ellipsis property
+ DALI_TEST_CHECK( !label.GetProperty<bool>( DevelTextLabel::Property::ELLIPSIS ) );
+ label.SetProperty( DevelTextLabel::Property::ELLIPSIS, true );
+ DALI_TEST_CHECK( label.GetProperty<bool>( DevelTextLabel::Property::ELLIPSIS ) );
+
END_TEST;
}
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
application.Render(0);
DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA), TEST_LOCATION );
DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 1.0f, 0.001f, TEST_LOCATION );
anim.Play();
application.Render(500); // Start animation
application.Render(500); // Halfway thru anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA+Color::RED)*0.5f, TEST_LOCATION);
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA+Color::RED)*0.5f, TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 1.0f, 0.001f, TEST_LOCATION );
application.Render(500); // End of anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::RED), TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::RED), TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 1.0f, 0.001f, TEST_LOCATION );
END_TEST;
}
application.Render(0);
DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA), TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 1.0f, 0.001f, TEST_LOCATION );
anim.Play();
application.Render(500); // Start animation
application.Render(500); // Halfway thru anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA+Color::RED)*0.5f, TEST_LOCATION);
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA+Color::RED)*0.5f, TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 1.0f, 0.001f, TEST_LOCATION);
application.Render(500); // End of anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::RED), TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::RED), TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 1.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
application.Render(0);
DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA), TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 1.0f, 0.001f, TEST_LOCATION );
anim.Play();
application.Render(500); // Start animation
application.Render(500); // Halfway thru anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA+Color::RED)*0.5f, TEST_LOCATION);
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA+Color::RED)*0.5f, TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 1.0f, 0.001f, TEST_LOCATION);
application.Render(500); // End of anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::RED), TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::RED), TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 1.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
application.Render(0);
DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(sizeIndex), Vector2(10.0f, 10.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( renderer, sizeIndex ), Vector2(10.0f, 10.0f), TEST_LOCATION);
anim.Play();
application.Render(500); // Start animation
application.Render(500); // Halfway thru anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(sizeIndex), Vector2(60.0f, 60.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( renderer, sizeIndex ), Vector2(60.0f, 60.0f), TEST_LOCATION);
application.Render(500); // End of anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(sizeIndex), Vector2(110.0f, 110.0f), TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( renderer, sizeIndex ), Vector2(110.0f, 110.0f), TEST_LOCATION );
END_TEST;
}
DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 0.0f, 0.001f, TEST_LOCATION );
DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::ON, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( renderer, Renderer::Property::BLEND_MODE ), (int)BlendMode::ON, TEST_LOCATION );
+
anim.Play();
application.SendNotification();
application.Render(500); // Start animation
application.Render(500); // Halfway thru anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 0.5f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::ON, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 0.5f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( renderer, Renderer::Property::BLEND_MODE ), (int)BlendMode::ON, TEST_LOCATION );
application.Render(501); // End of anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::AUTO, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA), TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 1.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( renderer, Renderer::Property::BLEND_MODE ), (int)BlendMode::AUTO, TEST_LOCATION );
END_TEST;
}
application.Render(0);
DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA), TEST_LOCATION);
DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 1.0f, 0.001f, TEST_LOCATION );
// Note, This should be testing for AUTO
// this is the same problem as C# target value being set before Play is called.
// @todo How was this solved?
DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::ON, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( renderer, Renderer::Property::BLEND_MODE ), (int)BlendMode::ON, TEST_LOCATION );
anim.Play();
application.Render(500); // Start animation
application.Render(500); // Halfway thru anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 0.5f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::ON, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 0.5f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( renderer, Renderer::Property::BLEND_MODE ), (int)BlendMode::ON, TEST_LOCATION );
application.Render(500); // End of anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 0.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::ON, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex ), Vector3(Color::MAGENTA), TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( renderer, opacityIndex ), 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( renderer, Renderer::Property::BLEND_MODE ), (int)BlendMode::ON, TEST_LOCATION );
END_TEST;
}
const char* const TEST_FILE( "test.mp4" );
const char* const VOLUME_LEFT( "volumeLeft" );
const char* const VOLUME_RIGHT( "volumeRight" );
+const char* const RENDERING_TYPE( "renderingTarget" );
}
left = right = 0.f;
Property::Map map;
- map.Insert( VOLUME_LEFT, 1.0f );
+ map.Insert( VOLUME_LEFT, 0.5f );
map.Insert( VOLUME_RIGHT, 0.5f );
- Property::Map map2;
view.SetProperty( VideoView::Property::VOLUME, map );
- Property::Value val4 = view.GetProperty( VideoView::Property::VOLUME );
- DALI_TEST_CHECK( val4.Get( map2 ) );
+ Property::Value val = view.GetProperty( VideoView::Property::VOLUME );
+
+ Property::Map map2;
+ DALI_TEST_CHECK( val.Get( map2 ) );
- Property::Value* volumeLeft = map.Find( VOLUME_LEFT );
- Property::Value* volumeRight = map.Find( VOLUME_RIGHT );
+ Property::Value* volumeLeft = map2.Find( VOLUME_LEFT );
+ Property::Value* volumeRight = map2.Find( VOLUME_RIGHT );
DALI_TEST_CHECK( volumeLeft && volumeLeft->Get( left ) );
DALI_TEST_CHECK( volumeRight && volumeRight->Get( right ) );
- DALI_TEST_CHECK( left == 1.0f );
+ DALI_TEST_CHECK( left == 0.5f );
DALI_TEST_CHECK( right == 0.5f );
END_TEST;
END_TEST;
}
+
+int UtcDaliVideoViewMethodsForRenderType(void)
+{
+ ToolkitTestApplication application;
+ VideoView videoView = VideoView::New();
+ DALI_TEST_CHECK( videoView );
+
+ Property::Map windowSurfaceTarget;
+ Property::Map nativeImageTarget;
+
+ windowSurfaceTarget.Insert( RENDERING_TYPE, "windowSurfaceTarget" );
+ nativeImageTarget.Insert( RENDERING_TYPE, "nativeImageTarget" );
+
+ Property::Map map;
+ Property::Value value;
+ videoView.SetProperty( VideoView::Property::VIDEO, windowSurfaceTarget );
+
+ value = videoView.GetProperty( VideoView::Property::VIDEO );
+ DALI_TEST_CHECK( value.Get( map ) );
+
+ Property::Value* type = map.Find( RENDERING_TYPE );
+ DALI_TEST_CHECK( type );
+ DALI_TEST_EQUALS( "windowSurfaceTarget", type->Get<std::string>(), TEST_LOCATION );
+
+ videoView.SetProperty( VideoView::Property::VIDEO, nativeImageTarget );
+
+ value = videoView.GetProperty( VideoView::Property::VIDEO );
+ DALI_TEST_CHECK( value.Get( map ) );
+ type = map.Find( RENDERING_TYPE );
+
+ DALI_TEST_CHECK( type );
+ DALI_TEST_EQUALS( "nativeImageTarget", type->Get<std::string>(), TEST_LOCATION );
+
+ END_TEST;
+}
application.Render(0);
application.Render(2000u); // halfway point between blue and white
- Vector4 color = renderer.GetProperty<Vector4>( borderColorIndex );
+ Vector4 color = DevelHandle::GetCurrentProperty< Vector4 >( renderer, borderColorIndex );
Vector4 testColor = (Color::BLUE + Color::WHITE)*0.5f;
DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor ), true, TEST_LOCATION );
- color = renderer.GetProperty<Vector3>( mixColorIndex );
+ color = DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex );
testColor = Vector4( 1,1,1,0.4f );
DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
application.Render(2000u);
- color = renderer.GetProperty<Vector4>( borderColorIndex );
+ color = DevelHandle::GetCurrentProperty< Vector4 >( renderer, borderColorIndex );
DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE ), true, TEST_LOCATION );
- color = renderer.GetProperty<Vector4>( mixColorIndex );
+ color = DevelHandle::GetCurrentProperty< Vector4 >( renderer, mixColorIndex );
testColor = Vector4(1,1,1,0);
DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
application.Render(0);
application.Render(2000u); // halfway point
- float size = renderer.GetProperty<float>( index );
+ float size = DevelHandle::GetCurrentProperty< float >( renderer, index );
DALI_TEST_EQUALS( size, 7.0f, 0.0001f, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f ), true, TEST_LOCATION );
application.Render(2000u); // halfway point between blue and white
- size = renderer.GetProperty<float>( index );
+ size = DevelHandle::GetCurrentProperty< float >( renderer, index );
DALI_TEST_EQUALS( size, 9.0f, 0.0001f, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f ), true, TEST_LOCATION );
application.Render(0);
application.Render(2000u); // halfway point
- Vector3 color = renderer.GetProperty<Vector3>( mixColorIndex );
+ Vector3 color = DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex );
Vector3 testColor = Vector3(Color::BLUE + Color::WHITE)*0.5f;
DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
application.Render(2000u); // halfway point between blue and white
- color = renderer.GetProperty<Vector3>( mixColorIndex );
+ color = DevelHandle::GetCurrentProperty< Vector3 >( renderer, mixColorIndex );
DALI_TEST_EQUALS( color, Vector3(Color::WHITE), TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE) ), true, TEST_LOCATION );
- blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ blendModeValue = DevelHandle::GetCurrentProperty( renderer, Renderer::Property::BLEND_MODE );
DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
END_TEST;
* @brief name "scrollBarFadeDuration", type float
* @details Sets the duration of scroll bar to fade out
*/
- SCROLL_BAR_FADE_DURATION
+ SCROLL_BAR_FADE_DURATION,
+
+ /**
+ * @brief The size of font in pixels.
+ * @details name "pixelSize", type float
+ */
+ PIXEL_SIZE
};
} // namespace Property
/**
* @brief Hides the input characters and instead shows a default character for password or pin entry.
* @details name "hiddenInputSettings", type map.
- * @SINCE_1_2.33
* @note Optional.
* @see HiddenInput
*/
HIDDEN_INPUT_SETTINGS = INPUT_OUTLINE + 1,
+
+ /**
+ * @brief The size of font in pixels.
+ * @details name "pixelSize", type float
+ */
+ PIXEL_SIZE = INPUT_OUTLINE + 2,
};
} // namespace Property
--- /dev/null
+#ifndef DALI_TOOLKIT_TEXT_LABEL_DEVEL_H
+#define DALI_TOOLKIT_TEXT_LABEL_DEVEL_H
+
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/text-controls/text-label.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace DevelTextLabel
+{
+
+namespace Property
+{
+ enum Type
+ {
+ RENDERING_BACKEND = Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND,
+ TEXT = Dali::Toolkit::TextLabel::Property::TEXT,
+ FONT_FAMILY = Dali::Toolkit::TextLabel::Property::FONT_FAMILY,
+ FONT_STYLE = Dali::Toolkit::TextLabel::Property::FONT_STYLE,
+ POINT_SIZE = Dali::Toolkit::TextLabel::Property::POINT_SIZE,
+ MULTI_LINE = Dali::Toolkit::TextLabel::Property::MULTI_LINE,
+ HORIZONTAL_ALIGNMENT = Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT,
+ VERTICAL_ALIGNMENT = Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT,
+ TEXT_COLOR = Dali::Toolkit::TextLabel::Property::TEXT_COLOR,
+ SHADOW_OFFSET = Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET,
+ SHADOW_COLOR = Dali::Toolkit::TextLabel::Property::SHADOW_COLOR,
+ UNDERLINE_ENABLED = Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED,
+ UNDERLINE_COLOR = Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR,
+ UNDERLINE_HEIGHT = Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT,
+ ENABLE_MARKUP = Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP,
+ ENABLE_AUTO_SCROLL = Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL,
+ AUTO_SCROLL_SPEED = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED,
+ AUTO_SCROLL_LOOP_COUNT = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT,
+ AUTO_SCROLL_GAP = Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP,
+ LINE_SPACING = Dali::Toolkit::TextLabel::Property::LINE_SPACING,
+ UNDERLINE = Dali::Toolkit::TextLabel::Property::UNDERLINE,
+ SHADOW = Dali::Toolkit::TextLabel::Property::SHADOW,
+ EMBOSS = Dali::Toolkit::TextLabel::Property::EMBOSS,
+ OUTLINE = Dali::Toolkit::TextLabel::Property::OUTLINE,
+
+ /**
+ * @brief The size of font in pixels.
+ * @details name "pixelSize", type float
+ */
+ PIXEL_SIZE = OUTLINE + 1,
+
+ /**
+ * @brief Enable or disable the ellipsis.
+ * @details name "ellipsis", type bool
+ */
+ ELLIPSIS = OUTLINE + 2,
+ };
+} // namespace Property
+
+} // namespace DevelText
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif // DALI_TOOLKIT_TEXT_LABEL_DEVEL_H
$(devel_api_src_dir)/controls/text-controls/hidden-input-properties.h \
$(devel_api_src_dir)/controls/text-controls/text-editor-devel.h \
$(devel_api_src_dir)/controls/text-controls/text-field-devel.h \
+ $(devel_api_src_dir)/controls/text-controls/text-label-devel.h \
$(devel_api_src_dir)/controls/text-controls/text-selection-popup.h \
$(devel_api_src_dir)/controls/text-controls/text-selection-toolbar.h
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/integration-api/debug.h>
#include <dali/devel-api/object/property-helper-devel.h>
+#include <dali/devel-api/object/handle-devel.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h>
Handle scrollableHandle = mScrollableObject.GetBaseHandle();
if(scrollableHandle)
{
- mScrollPositionIntervalReachedSignal.Emit(scrollableHandle.GetProperty<float>(mPropertyScrollPosition));
+ mScrollPositionIntervalReachedSignal.Emit( DevelHandle::GetCurrentProperty< float >( scrollableHandle, mPropertyScrollPosition ) );
}
}
}
ShowIndicator();
- mScrollStart = scrollableHandle.GetProperty<float>(mPropertyScrollPosition);
+ mScrollStart = DevelHandle::GetCurrentProperty< float >( scrollableHandle, mPropertyScrollPosition );
mGestureDisplacement = Vector3::ZERO;
mIsPanning = true;
mGestureDisplacement.x += gesture.displacement.x;
mGestureDisplacement.y += gesture.displacement.y;
- float minScrollPosition = scrollableHandle.GetProperty<float>( mPropertyMinScrollPosition );
- float maxScrollPosition = scrollableHandle.GetProperty<float>( mPropertyMaxScrollPosition );
+ float minScrollPosition = DevelHandle::GetCurrentProperty<float>( scrollableHandle, mPropertyMinScrollPosition );
+ float maxScrollPosition = DevelHandle::GetCurrentProperty<float>( scrollableHandle, mPropertyMaxScrollPosition );
// The domain size is the internal range
float domainSize = maxScrollPosition - minScrollPosition;
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/devel-api/object/property-helper-devel.h>
+#include <dali/devel-api/object/handle-devel.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scroll-bar/scroll-bar.h>
float ItemView::GetCurrentLayoutPosition(unsigned int itemId) const
{
- return Self().GetProperty<float>( Toolkit::ItemView::Property::LAYOUT_POSITION ) + static_cast<float>( itemId );
+ return DevelHandle::GetCurrentProperty< float >( Self(), Toolkit::ItemView::Property::LAYOUT_POSITION ) + static_cast<float>( itemId );
}
void ItemView::ActivateLayout(unsigned int layoutIndex, const Vector3& targetSize, float durationSeconds)
float firstItemScrollPosition = ClampFirstItemPosition(layoutPositionDelta, layoutSize, *mActiveLayout);
- float currentOvershoot = self.GetProperty<float>(Toolkit::ItemView::Property::OVERSHOOT);
+ float currentOvershoot = DevelHandle::GetCurrentProperty< float >( self, Toolkit::ItemView::Property::OVERSHOOT );
self.SetProperty(Toolkit::ItemView::Property::LAYOUT_POSITION, firstItemScrollPosition );
if(mOvershootAnimationSpeed > Math::MACHINE_EPSILON_0)
{
- float currentOvershoot = self.GetProperty<float>(Toolkit::ItemView::Property::OVERSHOOT);
+ float currentOvershoot = DevelHandle::GetCurrentProperty< float >( self, Toolkit::ItemView::Property::OVERSHOOT );
float duration = 0.0f;
if (mOvershootOverlay)
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// CLASS HEADER
#include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-overshoot-indicator-impl.h>
+// EXTERNAL INCLUDES
+#include <dali/devel-api/object/handle-devel.h>
+
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/scrollable/scrollable-impl.h>
#include <dali-toolkit/internal/controls/scrollable/bouncing-effect-actor.h>
void ScrollOvershootEffectRipple::OnOvershootNotification(PropertyNotification& source)
{
Actor self = mAttachedScrollView.Self();
- mOvershoot = self.GetProperty<float>(mOvershootProperty);
+ mOvershoot = DevelHandle::GetCurrentProperty< float >( self, mOvershootProperty );
SetOvershoot(mOvershoot, false);
UpdatePropertyNotifications();
}
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/public-api/object/property-map.h>
+#include <dali/devel-api/object/handle-devel.h>
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
if(child)
{
- Vector2 position = Self().GetProperty<Vector2>(Toolkit::ScrollView::Property::SCROLL_POSITION);
+ Vector2 position = DevelHandle::GetCurrentProperty<Vector2>( Self(), Toolkit::ScrollView::Property::SCROLL_POSITION );
// Get center-point of the Actor.
Vector3 childPosition = GetPositionOfAnchor(child, AnchorPoint::CENTER);
}
DALI_LOG_SCROLL_STATE("[0x%X] position-changed, mScrollTargetPosition[%.2f, %.2f], mScrollPrePosition[%.2f, %.2f], mScrollPostPosition[%.2f, %.2f]", this, mScrollTargetPosition.x, mScrollTargetPosition.y, mScrollPrePosition.x, mScrollPrePosition.y, mScrollPostPosition.x, mScrollPostPosition.y );
- DALI_LOG_SCROLL_STATE("[0x%X] SCROLL_PRE_POSITION[%.2f, %.2f], SCROLL_POSITION[%.2f, %.2f]", this, self.GetProperty( Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ).Get<Vector2>().x, self.GetProperty( Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ).Get<Vector2>().y, self.GetProperty( Toolkit::ScrollView::Property::SCROLL_POSITION ).Get<Vector2>().x, self.GetProperty( Toolkit::ScrollView::Property::SCROLL_POSITION ).Get<Vector2>().y );
+ DALI_LOG_SCROLL_STATE("[0x%X] SCROLL_PRE_POSITION[%.2f, %.2f], SCROLL_POSITION[%.2f, %.2f]", this, DevelHandle::GetCurrentProperty( self, Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ).Get<Vector2>().x, DevelHandle::GetCurrentProperty( self, Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ).Get<Vector2>().y, DevelHandle::GetCurrentProperty( self, Toolkit::ScrollView::Property::SCROLL_POSITION ).Get<Vector2>().x, DevelHandle::GetCurrentProperty( self, Toolkit::ScrollView::Property::SCROLL_POSITION ).Get<Vector2>().y );
}
SetScrollUpdateNotification(true);
Vector2 ScrollView::GetPropertyPrePosition() const
{
- Vector2 position = Self().GetProperty<Vector2>(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION);
+ Vector2 position = DevelHandle::GetCurrentProperty< Vector2 >( Self(), Toolkit::ScrollView::Property::SCROLL_PRE_POSITION );
WrapPosition(position);
return position;
}
Vector2 ScrollView::GetPropertyPosition() const
{
- Vector2 position = Self().GetProperty<Vector2>(Toolkit::ScrollView::Property::SCROLL_POSITION);
+ Vector2 position = DevelHandle::GetCurrentProperty< Vector2 >( Self(), Toolkit::ScrollView::Property::SCROLL_POSITION );
WrapPosition(position);
return position;
void ScrollView::ResetScrolling()
{
Actor self = Self();
- self.GetProperty(Toolkit::ScrollView::Property::SCROLL_POSITION).Get(mScrollPostPosition);
+ DevelHandle::GetCurrentProperty( self, Toolkit::ScrollView::Property::SCROLL_POSITION ).Get( mScrollPostPosition );
mScrollPrePosition = mScrollPostPosition;
DALI_LOG_SCROLL_STATE("[0x%X] Setting SCROLL_PRE_POSITION To[%.2f, %.2f]", this, mScrollPostPosition.x, mScrollPostPosition.y );
self.SetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION, mScrollPostPosition);
void ScrollView::UpdateLocalScrollProperties()
{
Actor self = Self();
- self.GetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION).Get(mScrollPrePosition);
- self.GetProperty(Toolkit::ScrollView::Property::SCROLL_POSITION).Get(mScrollPostPosition);
+ DevelHandle::GetCurrentProperty( self, Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ).Get( mScrollPrePosition );
+ DevelHandle::GetCurrentProperty( self, Toolkit::ScrollView::Property::SCROLL_POSITION ).Get( mScrollPostPosition );
}
// private functions
if( duration > Math::MACHINE_EPSILON_10 )
{
Actor self = Self();
- DALI_LOG_SCROLL_STATE("[0x%X], Animating from[%.2f] to[%.2f]", this, self.GetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION).Get<Vector2>().x, position );
+ DALI_LOG_SCROLL_STATE("[0x%X], Animating from[%.2f] to[%.2f]", this, DevelHandle::GetCurrentProperty( self, Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ).Get< Vector2 >().x, position );
mInternalXAnimation = Animation::New(duration);
DALI_LOG_SCROLL_STATE("[0x%X], mInternalXAnimation[0x%X]", this, mInternalXAnimation.GetObjectPtr() );
mInternalXAnimation.FinishedSignal().Connect(this, &ScrollView::OnScrollAnimationFinished);
if( duration > Math::MACHINE_EPSILON_10 )
{
Actor self = Self();
- DALI_LOG_SCROLL_STATE("[0x%X], Animating from[%.2f] to[%.2f]", this, self.GetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION).Get<Vector2>().y, position );
+ DALI_LOG_SCROLL_STATE("[0x%X], Animating from[%.2f] to[%.2f]", this, DevelHandle::GetCurrentProperty( self, Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ).Get< Vector2 >().y, position );
mInternalYAnimation = Animation::New(duration);
DALI_LOG_SCROLL_STATE("[0x%X], mInternalYAnimation[0x%X]", this, mInternalYAnimation.GetObjectPtr() );
mInternalYAnimation.FinishedSignal().Connect(this, &ScrollView::OnScrollAnimationFinished);
if( source == mInternalXAnimation )
{
- DALI_LOG_SCROLL_STATE("[0x%X] mInternalXAnimation[0x%X], expected[%.2f], actual[%.2f], post[%.2f]", this, mInternalXAnimation.GetObjectPtr(), mScrollTargetPosition.x, Self().GetProperty(SCROLL_PRE_POSITION).Get<Vector2>().x, mScrollPostPosition.x );
+ DALI_LOG_SCROLL_STATE("[0x%X] mInternalXAnimation[0x%X], expected[%.2f], actual[%.2f], post[%.2f]", this, mInternalXAnimation.GetObjectPtr(), mScrollTargetPosition.x, DevelHandle::GetCurrentProperty( Self(), SCROLL_PRE_POSITION ).Get< Vector2 >().x, mScrollPostPosition.x );
if( !(mScrollStateFlags & AnimatingInternalY) )
{
if( source == mInternalYAnimation )
{
- DALI_LOG_SCROLL_STATE("[0x%X] mInternalYAnimation[0x%X], expected[%.2f], actual[%.2f], post[%.2f]", this, mInternalYAnimation.GetObjectPtr(), mScrollTargetPosition.y, Self().GetProperty(SCROLL_PRE_POSITION).Get<Vector2>().y, mScrollPostPosition.y );
+ DALI_LOG_SCROLL_STATE("[0x%X] mInternalYAnimation[0x%X], expected[%.2f], actual[%.2f], post[%.2f]", this, mInternalYAnimation.GetObjectPtr(), mScrollTargetPosition.y, DevelHandle::GetProperty( Self(), SCROLL_PRE_POSITION ).Get< Vector2 >().y, mScrollPostPosition.y );
if( !(mScrollStateFlags & AnimatingInternalX) )
{
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextEditor, "enableScrollBar", BOOLEAN, ENABLE_SCROLL_BAR )
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextEditor, "scrollBarShowDuration", FLOAT, SCROLL_BAR_SHOW_DURATION )
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextEditor, "scrollBarFadeDuration", FLOAT, SCROLL_BAR_FADE_DURATION )
+DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextEditor, "pixelSize", FLOAT, PIXEL_SIZE )
DALI_SIGNAL_REGISTRATION( Toolkit, TextEditor, "textChanged", SIGNAL_TEXT_CHANGED )
DALI_SIGNAL_REGISTRATION( Toolkit, TextEditor, "inputStyleChanged", SIGNAL_INPUT_STYLE_CHANGED )
const float pointSize = value.Get< float >();
DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p POINT_SIZE %f\n", impl.mController.Get(), pointSize );
- if( !Equals( impl.mController->GetDefaultPointSize(), pointSize ) )
+ if( !Equals( impl.mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ), pointSize ) )
{
- impl.mController->SetDefaultPointSize( pointSize );
+ impl.mController->SetDefaultFontSize( pointSize, Text::Controller::POINT_SIZE );
}
}
break;
impl.mAnimationPeriod.durationSeconds = duration;
break;
}
+ case Toolkit::DevelTextEditor::Property::PIXEL_SIZE:
+ {
+ if( impl.mController )
+ {
+ const float pixelSize = value.Get< float >();
+ DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p PIXEL_SIZE %f\n", impl.mController.Get(), pixelSize );
+
+ if( !Equals( impl.mController->GetDefaultFontSize( Text::Controller::PIXEL_SIZE ), pixelSize ) )
+ {
+ impl.mController->SetDefaultFontSize( pixelSize, Text::Controller::PIXEL_SIZE );
+ }
+ }
+ break;
+ }
} // switch
} // texteditor
}
{
if( impl.mController )
{
- value = impl.mController->GetDefaultPointSize();
+ value = impl.mController->GetDefaultFontSize( Text::Controller::POINT_SIZE );
}
break;
}
value = impl.mAnimationPeriod.durationSeconds;
break;
}
+ case Toolkit::DevelTextEditor::Property::PIXEL_SIZE:
+ {
+ if( impl.mController )
+ {
+ value = impl.mController->GetDefaultFontSize( Text::Controller::PIXEL_SIZE );
+ }
+ break;
+ }
} //switch
}
DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "outline", MAP, OUTLINE )
DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "inputOutline", MAP, INPUT_OUTLINE )
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextField, "hiddenInputSettings", MAP, HIDDEN_INPUT_SETTINGS )
+DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextField, "pixelSize", FLOAT, PIXEL_SIZE )
DALI_SIGNAL_REGISTRATION( Toolkit, TextField, "textChanged", SIGNAL_TEXT_CHANGED )
DALI_SIGNAL_REGISTRATION( Toolkit, TextField, "maxLengthReached", SIGNAL_MAX_LENGTH_REACHED )
const float pointSize = value.Get< float >();
DALI_LOG_INFO( gLogFilter, Debug::General, "TextField %p POINT_SIZE %f\n", impl.mController.Get(), pointSize );
- if( !Equals( impl.mController->GetDefaultPointSize(), pointSize ) )
+ if( !Equals( impl.mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ), pointSize ) )
{
- impl.mController->SetDefaultPointSize( pointSize );
+ impl.mController->SetDefaultFontSize( pointSize, Text::Controller::POINT_SIZE );
}
}
break;
}
break;
}
+ case Toolkit::DevelTextField::Property::PIXEL_SIZE:
+ {
+ if( impl.mController )
+ {
+ const float pixelSize = value.Get< float >();
+ DALI_LOG_INFO( gLogFilter, Debug::General, "TextField %p PIXEL_SIZE %f\n", impl.mController.Get(), pixelSize );
+
+ if( !Equals( impl.mController->GetDefaultFontSize( Text::Controller::PIXEL_SIZE ), pixelSize ) )
+ {
+ impl.mController->SetDefaultFontSize( pixelSize, Text::Controller::PIXEL_SIZE );
+ }
+ }
+ break;
+ }
} // switch
} // textfield
}
{
if( impl.mController )
{
- value = impl.mController->GetDefaultPointSize();
+ value = impl.mController->GetDefaultFontSize( Text::Controller::POINT_SIZE );
}
break;
}
value = map;
break;
}
+ case Toolkit::DevelTextField::Property::PIXEL_SIZE:
+ {
+ if( impl.mController )
+ {
+ value = impl.mController->GetDefaultFontSize( Text::Controller::PIXEL_SIZE );
+ }
+ break;
+ }
} //switch
}
// EXTERNAL INCLUDES
#include <dali/public-api/object/type-registry-helper.h>
+#include <dali/devel-api/object/property-helper-devel.h>
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/text/rendering-backend.h>
#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
+#include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
#include <dali-toolkit/internal/text/property-string-parser.h>
#include <dali-toolkit/internal/text/rendering/text-backend.h>
#include <dali-toolkit/internal/text/text-effects-style.h>
DALI_PROPERTY_REGISTRATION( Toolkit, TextLabel, "shadow", MAP, SHADOW )
DALI_PROPERTY_REGISTRATION( Toolkit, TextLabel, "emboss", MAP, EMBOSS )
DALI_PROPERTY_REGISTRATION( Toolkit, TextLabel, "outline", MAP, OUTLINE )
+DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextLabel, "pixelSize", FLOAT, PIXEL_SIZE )
+DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextLabel, "ellipsis", BOOLEAN, ELLIPSIS )
DALI_TYPE_REGISTRATION_END()
{
const float pointSize = value.Get< float >();
- if( !Equals( impl.mController->GetDefaultPointSize(), pointSize ) )
+ if( !Equals( impl.mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ), pointSize ) )
{
- impl.mController->SetDefaultPointSize( pointSize );
+ impl.mController->SetDefaultFontSize( pointSize, Text::Controller::POINT_SIZE );
}
}
break;
}
break;
}
+ case Toolkit::DevelTextLabel::Property::PIXEL_SIZE:
+ {
+ if( impl.mController )
+ {
+ const float pixelSize = value.Get< float >();
+ DALI_LOG_INFO( gLogFilter, Debug::General, "TextLabel %p PIXEL_SIZE %f\n", impl.mController.Get(), pixelSize );
+
+ if( !Equals( impl.mController->GetDefaultFontSize( Text::Controller::PIXEL_SIZE ), pixelSize ) )
+ {
+ impl.mController->SetDefaultFontSize( pixelSize, Text::Controller::PIXEL_SIZE );
+ }
+ }
+ break;
+ }
+ case Toolkit::DevelTextLabel::Property::ELLIPSIS:
+ {
+ if( impl.mController )
+ {
+ const bool ellipsis = value.Get<bool>();
+ DALI_LOG_INFO( gLogFilter, Debug::General, "TextLabel %p ELLIPSIS %d\n", impl.mController.Get(), ellipsis );
+
+ impl.mController->SetTextElideEnabled( ellipsis );
+ }
+ break;
+ }
}
}
}
{
if( impl.mController )
{
- value = impl.mController->GetDefaultPointSize();
+ value = impl.mController->GetDefaultFontSize( Text::Controller::POINT_SIZE );
}
break;
}
GetOutlineProperties( impl.mController, value, Text::EffectStyle::DEFAULT );
break;
}
+ case Toolkit::DevelTextLabel::Property::PIXEL_SIZE:
+ {
+ if( impl.mController )
+ {
+ value = impl.mController->GetDefaultFontSize( Text::Controller::PIXEL_SIZE );
+ }
+ break;
+ }
+ case Toolkit::DevelTextLabel::Property::ELLIPSIS:
+ {
+ if( impl.mController )
+ {
+ value = impl.mController->IsTextElideEnabled();
+ }
+ break;
+ }
}
}
const char* const VOLUME_LEFT( "volumeLeft" );
const char* const VOLUME_RIGHT( "volumeRight" );
-const char* const RENDERING_TARGET( "RENDERING_TARGET" );
+const char* const RENDERING_TARGET( "renderingTarget" );
const char* const WINDOW_SURFACE_TARGET( "windowSurfaceTarget" );
const char* const NATIVE_IMAGE_TARGET( "nativeImageTarget" );
VideoView::VideoView()
: Control( ControlBehaviour( ACTOR_BEHAVIOUR_DEFAULT | DISABLE_STYLE_CHANGE_SIGNALS ) ),
mCurrentVideoPlayPosition( 0 ),
- mSetRenderingTarget( false ),
+ mIsNativeImageTarget( true ),
mIsPlay( false ),
mIsPause( false )
{
return handle;
}
+void VideoView::OnInitialize()
+{
+ Any source;
+ Dali::NativeImageSourcePtr nativeImageSourcePtr = Dali::NativeImageSource::New( source );
+ mNativeImage = Dali::NativeImage::New( *nativeImageSourcePtr );
+
+ mVideoPlayer.SetRenderingTarget( nativeImageSourcePtr );
+ mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
+}
+
void VideoView::SetUrl( const std::string& url )
{
if( mUrl != url || !mPropertyMap.Empty() )
{
- mPropertyMap.Clear();
-
mUrl = url;
+ mPropertyMap.Clear();
}
- if( mSetRenderingTarget )
- {
- mVideoPlayer.SetUrl( mUrl );
- }
- else
+ if( mIsNativeImageTarget )
{
- SetNativeImageTarget();
+ Actor self( Self() );
+ Internal::InitializeVisual( self, mVisual, mNativeImage );
}
+
+ mVideoPlayer.SetUrl( mUrl );
}
void VideoView::SetPropertyMap( Property::Map map )
Actor self = Self();
int curPos = mVideoPlayer.GetPlayPosition();
- mSetRenderingTarget = true;
-
if( mVisual )
{
Toolkit::GetImplementation(mVisual).SetOffStage(self);
mVideoPlayer.SetRenderingTarget( Dali::Adaptor::Get().GetNativeWindowHandle() );
mVideoPlayer.SetUrl( mUrl );
- mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
+
+ mIsNativeImageTarget = false;
if( mIsPlay )
{
Actor self( Self() );
int curPos = mVideoPlayer.GetPlayPosition();
- mSetRenderingTarget = true;
-
Any source;
Dali::NativeImageSourcePtr nativeImageSourcePtr = Dali::NativeImageSource::New( source );
mNativeImage = Dali::NativeImage::New( *nativeImageSourcePtr );
mVideoPlayer.SetRenderingTarget( nativeImageSourcePtr );
mVideoPlayer.SetUrl( mUrl );
- mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
Internal::InitializeVisual( self, mVisual, mNativeImage );
+ mIsNativeImageTarget = true;
if( mIsPlay )
{
*/
void SetDepthIndex( int depthIndex );
-
/**
* @brief Performs actions as requested using the action name.
* @SINCE_1_1.38
private: // From Control
/**
+ * @copydoc Toolkit::Control::OnInitialize()
+ */
+ virtual void OnInitialize();
+
+ /**
* @copydoc Toolkit::Control::OnStageConnect()
*/
virtual void OnStageConnection( int depth );
Dali::Toolkit::VideoView::VideoViewSignalType mFinishedSignal;
std::string mUrl;
int mCurrentVideoPlayPosition;
- bool mSetRenderingTarget;
+ bool mIsNativeImageTarget;
bool mIsPlay;
bool mIsPause;
};
namespace
{
-const char* LANDSCAPE_QUALIFIER = "landscape";
+//const char* LANDSCAPE_QUALIFIER = "landscape";
const char* PORTRAIT_QUALIFIER = "portrait";
const char* FONT_SIZE_QUALIFIER = "fontsize";
static void CollectQualifiers( std::vector<std::string>& qualifiersOut )
{
// Append the relevant qualifier for orientation
- int orientation = 0; // Get the orientation from the system
- switch( orientation )
- {
- case 90:
- case 270:
- {
- qualifiersOut.push_back( std::string( LANDSCAPE_QUALIFIER ) );
- break;
- }
- case 180:
- case 0: // fall through
- default:
- {
- qualifiersOut.push_back( std::string( PORTRAIT_QUALIFIER ) );
- break;
- }
- }
+ // int orientation = 0; // Get the orientation from the system
+ /*
+ //// To Do /////
+ Getting orientation from the system, and determine Qualifie LANDSCAPE or PORTRAIT
+ orientation 0, 180 : PORTRAIT_QUALIFIER (default)
+ orientation 90, 270 : LANDSCAPE_QUALIFIER
+ */
+
+ qualifiersOut.push_back( std::string( PORTRAIT_QUALIFIER ) );
+
}
/**
#include <dali/public-api/adaptor-framework/key.h>
#include <dali/integration-api/debug.h>
#include <dali/devel-api/adaptor-framework/clipboard-event-notifier.h>
+#include <dali/devel-api/text-abstraction/font-client.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/text/bidirectional-support.h>
return TextAbstraction::FontSlant::NORMAL;
}
-void Controller::SetDefaultPointSize( float pointSize )
+void Controller::SetDefaultFontSize( float fontSize, FontSizeType type )
{
if( NULL == mImpl->mFontDefaults )
{
mImpl->mFontDefaults = new FontDefaults();
}
- mImpl->mFontDefaults->mDefaultPointSize = pointSize;
- mImpl->mFontDefaults->sizeDefined = true;
+ switch( type )
+ {
+ case POINT_SIZE:
+ {
+ mImpl->mFontDefaults->mDefaultPointSize = fontSize;
+ mImpl->mFontDefaults->sizeDefined = true;
+ break;
+ }
+ case PIXEL_SIZE:
+ {
+ // Point size = Pixel size * 72 / DPI
+ unsigned int horizontalDpi = 0u;
+ unsigned int verticalDpi = 0u;
+ TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
+ fontClient.GetDpi( horizontalDpi, verticalDpi );
+
+ mImpl->mFontDefaults->mDefaultPointSize = ( fontSize * 72 ) / horizontalDpi;
+ mImpl->mFontDefaults->sizeDefined = true;
+ break;
+ }
+ default:
+ {
+ DALI_ASSERT_ALWAYS( false );
+ }
+ }
// Clear the font-specific data
ClearFontData();
mImpl->RequestRelayout();
}
-float Controller::GetDefaultPointSize() const
+float Controller::GetDefaultFontSize( FontSizeType type ) const
{
+ float value = 0.0f;
if( NULL != mImpl->mFontDefaults )
{
- return mImpl->mFontDefaults->mDefaultPointSize;
+ switch( type )
+ {
+ case POINT_SIZE:
+ {
+ value = mImpl->mFontDefaults->mDefaultPointSize;
+ break;
+ }
+ case PIXEL_SIZE:
+ {
+ // Pixel size = Point size * DPI / 72
+ unsigned int horizontalDpi = 0u;
+ unsigned int verticalDpi = 0u;
+ TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
+ fontClient.GetDpi( horizontalDpi, verticalDpi );
+
+ value = mImpl->mFontDefaults->mDefaultPointSize * horizontalDpi / 72;
+ break;
+ }
+ default:
+ {
+ DALI_ASSERT_ALWAYS( false );
+ }
+ }
+ return value;
}
- return 0.0f;
+ return value;
}
void Controller::SetDefaultColor( const Vector4& color )
}
// Return the default font's point size if there is no EventData.
- return GetDefaultPointSize();
+ return GetDefaultFontSize( Text::Controller::POINT_SIZE );
}
void Controller::SetInputLineSpacing( float lineSpacing )
PLACEHOLDER_TYPE_INACTIVE,
};
+ /**
+ * @brief Enumeration for Font Size Type.
+ */
+ enum FontSizeType
+ {
+ POINT_SIZE, // The size of font in points.
+ PIXEL_SIZE // The size of font in pixels.
+ };
+
struct NoTextTap
{
enum Action
FontSlant GetDefaultFontSlant() const;
/**
- * @brief Set the default point size.
+ * @brief Set the default font size.
*
- * @param[in] pointSize The default point size.
+ * @param[in] size The default font size.
+ * @param[in] type The font size type is point size or pixel size
*/
- void SetDefaultPointSize( float pointSize );
+ void SetDefaultFontSize( float fontSize, FontSizeType type );
/**
* @brief Retrieve the default point size.
*
+ * @param[in] type The font size type
* @return The default point size.
*/
- float GetDefaultPointSize() const;
+ float GetDefaultFontSize( FontSizeType type ) const;
/**
* @brief Sets the text's default color.
GetFontStyleProperty( mController, value, Text::FontStyle::DEFAULT );
map.Insert( Toolkit::TextVisual::Property::FONT_STYLE, value );
- map.Insert( Toolkit::TextVisual::Property::POINT_SIZE, mController->GetDefaultPointSize() );
+ map.Insert( Toolkit::TextVisual::Property::POINT_SIZE, mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ) );
map.Insert( Toolkit::TextVisual::Property::MULTI_LINE, mController->IsMultiLineEnabled() );
case Toolkit::TextVisual::Property::POINT_SIZE:
{
const float pointSize = propertyValue.Get<float>();
- if( !Equals( mController->GetDefaultPointSize(), pointSize ) )
+ if( !Equals( mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ), pointSize ) )
{
- mController->SetDefaultPointSize( pointSize );
+ mController->SetDefaultFontSize( pointSize, Text::Controller::POINT_SIZE );
}
break;
}
Property::Map map;
DoCreatePropertyMap( map );
Property::Value* valuePtr = map.Find( Toolkit::DevelVisual::Property::TYPE );
- int visualType;
- valuePtr->Get(visualType);
+ int visualType = -1;
+ if( valuePtr )
+ {
+ valuePtr->Get( visualType );
+ }
if( animator.propertyKey == Toolkit::DevelVisual::Property::MIX_COLOR ||
animator.propertyKey == MIX_COLOR ||
}
else if( mImpl->mRenderer )
{
- AnimateRendererProperty(transition, animator);
+ AnimateRendererProperty( transition, animator );
}
}
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 2;
-const unsigned int TOOLKIT_MICRO_VERSION = 36;
+const unsigned int TOOLKIT_MICRO_VERSION = 37;
const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
{
int r = -1, g = -1, b = -1;
char s1[32]="", s2[32]="";
- sscanf(str + 4, "%d%[%%, \t]%d%[%%, \t]%d", &r, s1, &g, s2, &b);
+
+ /**
+ * In the original file, the formatted data reading did not specify the string with width limitation.
+ * To prevent the possible overflow, we replace '%s' with '%32s' here.
+ */
+ sscanf(str + 4, "%d%32[%%, \t]%d%32[%%, \t]%d", &r, s1, &g, s2, &b);
if (strchr(s1, '%')) {
return NSVG_RGB((r*255)/100,(g*255)/100,(b*255)/100);
} else {
Name: dali-toolkit
Summary: The OpenGLES Canvas Core Library Toolkit
-Version: 1.2.36
+Version: 1.2.37
Release: 1
Group: System/Libraries
-License: Apache-2.0 and BSD-2-Clause and MIT
+License: Apache-2.0 and BSD-3-Clause and MIT
URL: https://review.tizen.org/git/?p=platform/core/uifw/dali-toolkit.git;a=summary
Source0: %{name}-%{version}.tar.gz
--- /dev/null
+build/aclocal.m4
+build/config.log
+build/config.status
+build/config/
+build/configure
+build/autom4te.cache/
+examples/*.exe
+NDali.dll
+../examples/NDali.dll
return jresult;
}
-typedef void* (SWIGSTDCALL* SWIG_CallbackKbPreFocusChange)(void *, void *, int);
+typedef Dali::Actor * (SWIGSTDCALL* SWIG_CallbackKbPreFocusChange)(Dali::Actor *, Dali::Actor *, int);
SWIG_CallbackKbPreFocusChange swig_callbackOnKbPreFocusChange;
Dali::Actor OnKbPreFocusChangeCallback(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction)
{
Dali::Actor *actorp;
Dali::Actor actor;
+ Dali::Actor *CurrentP = NULL;
+ Dali::Actor *ProposedP = NULL;
- actorp = (Dali::Actor *)swig_callbackOnKbPreFocusChange((void *)¤t, (void *)&proposed, direction);
- actor = *actorp;
+ if (current)
+ {
+ CurrentP = (Dali::Actor *)¤t;
+ }
+
+ if (proposed)
+ {
+ ProposedP = (Dali::Actor *)&proposed;
+ }
+
+ actorp = (Dali::Actor *)swig_callbackOnKbPreFocusChange(CurrentP, ProposedP, direction);
+
+ if (actorp)
+ {
+ actor = *actorp;
+ }
return actor;
}
private Dali.Application _application;
private TableView _contentContainer;
private Timer _timer;
- private Stage _stage;
+ private Window _window;
private Popup _popup;
private ProgressBar _progressBar;
public void OnInitialize(object source, NUIApplicationInitEventArgs e)
{
Console.WriteLine("Customized Application Initialize event handler");
- _stage = Stage.GetCurrent();
- _stage.BackgroundColor = Color.White;
+ _window = Window.Instance;
+ _window.BackgroundColor = Color.White;
// Top label
TextLabel topLabel = new TextLabel();
topLabel.HorizontalAlignment = "BEGIN";
topLabel.VerticalAlignment = "CENTER";
topLabel.PointSize = 42.0f;
- _stage.Add(topLabel);
+ _window.Add(topLabel);
// Grid container to contain items. Use tableView because FlexContainer support focus navigation just two direction ( up/down or left/right )
_contentContainer = new TableView(6, 5);
_contentContainer.SetResizePolicy(ResizePolicyType.SIZE_RELATIVE_TO_PARENT, DimensionType.HEIGHT);
_contentContainer.SetSizeModeFactor(new Vector3(0.0f, 0.9f, 0.0f));
_contentContainer.AnchorPoint = NDalic.AnchorPointBottomCenter;
- _contentContainer.Position = new Position(0, _stage.Size.Height * 0.1f, 0);
+ _contentContainer.Position = new Position(0, _window.Size.Height * 0.1f, 0);
_contentContainer.SetRelativeHeight(0, 0.07f);
_contentContainer.SetRelativeHeight(1, 0.26f);
_contentContainer.SetRelativeHeight(2, 0.07f);
_contentContainer.SetRelativeHeight(4, 0.07f);
_contentContainer.SetRelativeHeight(5, 0.26f);
_contentContainer.SetKeyboardFocusable(true);
- _stage.Add(_contentContainer);
+ _window.Add(_contentContainer);
CreateContent();
}
// Callback for KeyboardFocusManager
- private Actor OnPreFocusChange(object source, FocusManager.PreFocusChangeEventArgs e)
+ private View OnPreFocusChange(object source, FocusManager.PreFocusChangeEventArgs e)
{
if (!e.Proposed && !e.Current)
{
{
// Make label for item
TextLabel itemLabel = new TextLabel(" " + item.name);
- itemLabel.Size = new Vector3(_stage.GetSize().Width * 0.2f, _stage.GetSize().Height * 0.05f, 0.0f);
+ itemLabel.Size = new Vector3(_window.GetSize().Width * 0.2f, _window.GetSize().Height * 0.05f, 0.0f);
itemLabel.HorizontalAlignment = "BEGIN";
itemLabel.VerticalAlignment = "BOTTOM";
itemLabel.PointSize = 18.0f;
_contentContainer.AddChild(itemLabel, new TableView.CellPosition(((uint)idx / 5) * 2, (uint)idx % 5));
- // If item is implemented in public, attach it on stage
+ // If item is implemented in public, attach it on window
if (item.isImplemented)
{
if (item.name.CompareTo("PushButton") == 0)
button.Clicked += (obj, ee) =>
{
- _stage.Add(_popup);
+ _window.Add(_popup);
_popup.SetDisplayState(Popup.DisplayStateType.SHOWN);
- FocusManager.Instance.SetCurrentFocusActor((_popup.FindChildByName("Footer")).FindChildByName("OKButton"));
+ FocusManager.Instance.SetCurrentFocusView((_popup.FindChildByName("Footer")).FindChildByName("OKButton"));
return true;
};
_contentContainer.AddChild(button, new TableView.CellPosition(((uint)idx / 5) * 2 + 1, (uint)idx % 5));
text.MultiLine = true;
text.HorizontalAlignment = "center";
toast.SetTitle(text);
- _stage.Add(toast);
+ _window.Add(toast);
toast.SetDisplayState(Popup.DisplayStateType.SHOWN);
}
}
else
{
ImageView notSupportView = new ImageView("images/not_yet_sign.png");
- notSupportView.Size = new Vector3(_stage.GetSize().Width * 0.2f, _stage.GetSize().Height * 0.25f, 0.0f);
+ notSupportView.Size = new Vector3(_window.GetSize().Width * 0.2f, _window.GetSize().Height * 0.25f, 0.0f);
notSupportView.SetKeyboardFocusable(true);
_contentContainer.AddChild(notSupportView, new TableView.CellPosition(((uint)idx / 5) * 2 + 1, (uint)idx % 5));
{
Popup confirmationPopup = new Popup();
- Actor footer = new Actor();
+ View footer = new View();
footer.SetName("Footer");
footer.SetResizePolicy(ResizePolicyType.FILL_TO_PARENT, DimensionType.WIDTH);
footer.SetResizePolicy(ResizePolicyType.FIXED, DimensionType.HEIGHT);
confirmationPopup.SetFooter(footer);
return confirmationPopup;
}
- Actor CreateTitle(string title)
+ View CreateTitle(string title)
{
TextLabel titleActor = new TextLabel(title);
titleActor.TextColor = Color.White;
private Dali.Application _application;
private Animation _animation;
private TextLabel _text;
- private Stage _stage;
+ private Window _window;
public Example(Dali.Application application)
{
public void Initialize(object source, NUIApplicationInitEventArgs e)
{
Console.WriteLine("Customized Application Initialize event handler");
- _stage = Stage.Instance;
- _stage.BackgroundColor = Color.White;
- _stage.Touch += OnStageTouched;
+ _window = Window.Instance;
+ _window.BackgroundColor = Color.White;
+ _window.Touch += OnWindowTouched;
// Add a _text label to the stage
_text = new TextLabel("Hello Mono World");
_text.HorizontalAlignment = "CENTER";
_text.PointSize = 32.0f;
_text.TextColor = Color.Magenta;
- _stage.Add(_text);
+ _window.Add(_text);
_animation = new Animation
{
}
}
- // Callback for stage touched signal handling
- public void OnStageTouched(object sender, Stage.TouchEventArgs e)
+ // Callback for window touched signal handling
+ public void OnWindowTouched(object sender, Window.TouchEventArgs e)
{
// Only animate the _text label when touch down happens
if (e.Touch.GetState(0) == PointStateType.DOWN)
private bool _isAniFinised = true;
private Layer layer, _layer1, _layer2;
private PushButton _pushButton1, _pushButton2;
- private Stage stage;
+ private Window window;
public Example(Dali.Application application)
{
public void Initialize(object source, NUIApplicationInitEventArgs e)
{
Log("Customized Application Initialize event handler");
- stage = Stage.Instance;
- stage.BackgroundColor = Color.Cyan;
- stage.Touch += OnStageTouched;
- stage.Wheel += OnStageWheelMoved;
- stage.Key += OnStageKeyPressed;
- //stage.EventProcessingFinished += OnStageEventProcessingFinished;
-
- layer = stage.GetDefaultLayer();
+ window = Window.Instance;
+ window.BackgroundColor = Color.Cyan;
+ window.Touch += OnWindowTouched;
+ window.Wheel += OnWindowWheelMoved;
+ window.Key += OnWindowKeyPressed;
+ //window.EventProcessingFinished += OnWindowEventProcessingFinished;
+
+ layer = window.GetDefaultLayer();
_layer1 = new Layer();
_layer2 = new Layer();
- stage.AddLayer(_layer1);
- stage.AddLayer(_layer2);
+ window.Add(_layer1);
+ window.Add(_layer2);
Log("_layer1.Behavior =" + _layer1.Behavior);
if (_layer1.Behavior == Layer.LayerBehavior.LAYER_UI)
{
_layer1.Behavior = Layer.LayerBehavior.LAYER_2D;
Log("again _layer1.Behavior =" + _layer1.Behavior);
}
- // Add a ImageView to the stage
+ // Add a ImageView to the window
_imageView = new ImageView();
_imageView.ResourceUrl = "./images/gallery-3.jpg";
_imageView.ParentOrigin = ParentOrigin.Center;
_pushButton1.ParentOrigin = ParentOrigin.BottomLeft;
_pushButton1.AnchorPoint = AnchorPoint.BottomLeft;
_pushButton1.LabelText = "start animation";
- _pushButton1.Position = new Vector3(0.0f, stage.Size.Height * 0.1f, 0.0f);
+ _pushButton1.Position = new Vector3(0.0f, window.Size.Height * 0.1f, 0.0f);
_pushButton1.Clicked += OnPushButtonClicked1;
_layer1.Add(_pushButton1);
_pushButton2.ParentOrigin = ParentOrigin.BottomLeft;
_pushButton2.AnchorPoint = AnchorPoint.BottomLeft;
_pushButton2.LabelText = "reload image with same URL";
- _pushButton2.Position = new Vector3(0.0f, stage.Size.Height * 0.2f, 0.0f);
+ _pushButton2.Position = new Vector3(0.0f, window.Size.Height * 0.2f, 0.0f);
_pushButton2.Clicked += OnPushButtonClicked2;
_layer2.Add(_pushButton2);
_animation.TargetProperty = "Size";
KeyFrames _keyFrames = new KeyFrames();
_keyFrames.Add(0.0f, new Size(0.0f, 0.0f, 0.0f));
- _keyFrames.Add(0.3f, new Size((stage.Size * 0.7f)));
- _keyFrames.Add(1.0f, new Size(stage.Size));
+ _keyFrames.Add(0.3f, new Size((window.Size * 0.7f)));
+ _keyFrames.Add(1.0f, new Size(window.Size));
_animation.AnimateBetween(_imageView, _keyFrames, Animation.Interpolation.Linear);
_animation.EndAction = Animation.EndActions.Discard;
}
}
- public void OnStageEventProcessingFinished(object sender, EventArgs e)
+ public void OnWindowEventProcessingFinished(object sender, EventArgs e)
{
- Log("OnStageEventProcessingFinished()!");
+ Log("OnWindowEventProcessingFinished()!");
if (e != null)
{
Log("e != null !");
}
}
- public void OnStageKeyPressed(object sender, Stage.KeyEventArgs e)
+ public void OnWindowKeyPressed(object sender, Window.KeyEventArgs e)
{
- Log("OnStageKeyEventOccured()!");
+ Log("OnWindowKeyEventOccured()!");
Log("keyPressedName=" + e.Key.KeyPressedName);
Log("state=" + e.Key.State);
}
- public void OnStageWheelMoved(object sender, Stage.WheelEventArgs e)
+ public void OnWindowWheelMoved(object sender, Window.WheelEventArgs e)
{
- Log("OnStageWheelEventOccured()!");
+ Log("OnWindowWheelEventOccured()!");
Log("direction=" + e.Wheel.Direction);
Log("type=" + e.Wheel.Type);
}
- // Callback for stage touched signal handling
- public void OnStageTouched(object sender, Stage.TouchEventArgs e)
+ // Callback for window touched signal handling
+ public void OnWindowTouched(object sender, Window.TouchEventArgs e)
{
- Log("OnStageTouched()! e.TouchData.GetState(0)=" + e.Touch.GetState(0));
+ Log("OnWindowTouched()! e.TouchData.GetState(0)=" + e.Touch.GetState(0));
}
public void MainLoop()
namespace MyCSharpExample
{
- class Example
- {
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- delegate void CallbackDelegate(IntPtr data);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- delegate void ActorCallbackDelegate(IntPtr data);
-
- private Dali.Application _application;
- private ScrollView _scrollView;
- private ScrollBar _scrollBar;
- private Animation _animation;
- private TextLabel _text;
-
- public Example(Dali.Application application)
+ class Example
{
- _application = application;
- _application.Initialized += Initialize;
- }
+ private Dali.Application _application;
+ private ScrollView _scrollView;
+ private ScrollBar _scrollBar;
+ private Animation _animation;
+ private TextLabel _text;
+ public Example(Dali.Application application)
+ {
+ _application = application;
+ _application.Initialized += Initialize;
+ }
- public void Initialize(object source, NUIApplicationInitEventArgs e)
- {
- CreateScrollView();
- }
+ public void Initialize(object source, NUIApplicationInitEventArgs e)
+ {
+ CreateScrollView();
+ }
- private void CreateScrollView()
- {
- Stage stage = Stage.GetCurrent();
- stage.BackgroundColor = Color.White;
-
- // Create a scroll view
- _scrollView = new ScrollView();
- Size2D stageSize = stage.Size;
- _scrollView.Size = new Position(stageSize.Width, stageSize.Height, 0.0f);
- _scrollView.ParentOrigin = NDalic.ParentOriginCenter;
- _scrollView.AnchorPoint = NDalic.AnchorPointCenter;
- stage.Add(_scrollView);
-
- // Add actors to a scroll view with 3 pages
- int pageRows = 1;
- int pageColumns = 3;
- for(int pageRow = 0; pageRow < pageRows; pageRow++)
- {
- for(int pageColumn = 0; pageColumn < pageColumns; pageColumn++)
+ private void CreateScrollView()
{
- View pageActor = new View();
- pageActor.SetResizePolicy(ResizePolicyType.FILL_TO_PARENT, DimensionType.ALL_DIMENSIONS);
- pageActor.ParentOrigin = NDalic.ParentOriginCenter;
- pageActor.AnchorPoint = NDalic.AnchorPointCenter;
- pageActor.Position = new Position(pageColumn * stageSize.Width, pageRow * stageSize.Height, 0.0f);
-
- // Add images in a 3x4 grid layout for each page
- int imageRows = 4;
- int imageColumns = 3;
- float margin = 10.0f;
- Position imageSize = new Position((stageSize.Width / imageColumns) - margin, (stageSize.Height/ imageRows) - margin, 0.0f);
-
- for(int row = 0; row < imageRows; row++)
- {
- for(int column = 0; column < imageColumns;column++)
+ Window window = Window.Instance;
+ window.BackgroundColor = Color.White;
+
+ // Create a scroll view
+ _scrollView = new ScrollView();
+ Size2D windowSize = window.Size;
+ _scrollView.Size = new Position(windowSize.Width, windowSize.Height, 0.0f);
+ _scrollView.ParentOrigin = NDalic.ParentOriginCenter;
+ _scrollView.AnchorPoint = NDalic.AnchorPointCenter;
+ window.Add(_scrollView);
+
+ // Add actors to a scroll view with 3 pages
+ int pageRows = 1;
+ int pageColumns = 3;
+ for (int pageRow = 0; pageRow < pageRows; pageRow++)
{
- int imageId = (row * imageColumns + column) % 2 + 1;
- ImageView imageView = new ImageView("images/image-" + imageId + ".jpg");
- imageView.ParentOrigin = NDalic.ParentOriginCenter;
- imageView.AnchorPoint = NDalic.AnchorPointCenter;
- imageView.Size = imageSize;
- imageView.Position = new Position( margin * 0.5f + (imageSize.X + margin) * column - stageSize.Width * 0.5f + imageSize.X * 0.5f,
- margin * 0.5f + (imageSize.Y + margin) * row - stageSize.Height * 0.5f + imageSize.Y * 0.5f, 0.0f );
- pageActor.Add(imageView);
+ for (int pageColumn = 0; pageColumn < pageColumns; pageColumn++)
+ {
+ View pageActor = new View();
+ pageActor.SetResizePolicy(ResizePolicyType.FILL_TO_PARENT, DimensionType.ALL_DIMENSIONS);
+ pageActor.ParentOrigin = NDalic.ParentOriginCenter;
+ pageActor.AnchorPoint = NDalic.AnchorPointCenter;
+ pageActor.Position = new Position(pageColumn * windowSize.Width, pageRow * windowSize.Height, 0.0f);
+
+ // Add images in a 3x4 grid layout for each page
+ int imageRows = 4;
+ int imageColumns = 3;
+ float margin = 10.0f;
+ Position imageSize = new Position((windowSize.Width / imageColumns) - margin, (windowSize.Height / imageRows) - margin, 0.0f);
+
+ for (int row = 0; row < imageRows; row++)
+ {
+ for (int column = 0; column < imageColumns; column++)
+ {
+ int imageId = (row * imageColumns + column) % 2 + 1;
+ ImageView imageView = new ImageView("images/image-" + imageId + ".jpg");
+ imageView.ParentOrigin = NDalic.ParentOriginCenter;
+ imageView.AnchorPoint = NDalic.AnchorPointCenter;
+ imageView.Size = imageSize;
+ imageView.Position = new Position(margin * 0.5f + (imageSize.X + margin) * column - windowSize.Width * 0.5f + imageSize.X * 0.5f,
+ margin * 0.5f + (imageSize.Y + margin) * row - windowSize.Height * 0.5f + imageSize.Y * 0.5f, 0.0f);
+ pageActor.Add(imageView);
+ }
+ }
+
+ _scrollView.Add(pageActor);
+ }
}
- }
- _scrollView.Add(pageActor);
+ _scrollView.SetAxisAutoLock(true);
+
+ // Set scroll view to have 3 pages in X axis and allow page snapping,
+ // and also disable scrolling in Y axis.
+ RulerPtr scrollRulerX = new RulerPtr(new FixedRuler(windowSize.Width));
+ RulerPtr scrollRulerY = new RulerPtr(new DefaultRuler());
+ scrollRulerX.SetDomain(new RulerDomain(0.0f, windowSize.Width * pageColumns, true));
+ scrollRulerY.Disable();
+ _scrollView.SetRulerX(scrollRulerX);
+ _scrollView.SetRulerY(scrollRulerY);
+
+ // Create a horizontal scroll bar in the bottom of scroll view (which is optional)
+ _scrollBar = new ScrollBar();
+ _scrollBar.ParentOrigin = NDalic.ParentOriginBottomLeft;
+ _scrollBar.AnchorPoint = NDalic.AnchorPointTopLeft;
+ _scrollBar.SetResizePolicy(ResizePolicyType.FIT_TO_CHILDREN, DimensionType.WIDTH);
+ _scrollBar.SetResizePolicy(ResizePolicyType.FILL_TO_PARENT, DimensionType.HEIGHT);
+ _scrollBar.Orientation = new Rotation(new Radian(new Degree(270.0f)), Vector3.ZAXIS);
+ _scrollBar.SetScrollDirection(ScrollBar.Direction.Horizontal);
+ _scrollView.Add(_scrollBar);
+
+ // Connect to the OnRelayout signal
+ _scrollView.OnRelayoutEvent += OnScrollViewRelayout;
+ _scrollView.Touched += OnTouch;
+ _scrollView.WheelMoved += Onwheel;
+ _scrollView.KeyInputFocusGained += OnKey;
+ _text = new TextLabel("View Touch Event Handler Test");
+ _text.AnchorPoint = NDalic.AnchorPointTopLeft;
+ _text.HorizontalAlignment = "CENTER";
+ _text.PointSize = 48.0f;
+
+ _scrollView.Add(_text);
}
- }
-
- _scrollView.SetAxisAutoLock(true);
-
- // Set scroll view to have 3 pages in X axis and allow page snapping,
- // and also disable scrolling in Y axis.
- RulerPtr scrollRulerX = new RulerPtr(new FixedRuler(stageSize.Width));
- RulerPtr scrollRulerY = new RulerPtr(new DefaultRuler());
- scrollRulerX.SetDomain(new RulerDomain(0.0f, stageSize.Width * pageColumns, true));
- scrollRulerY.Disable();
- _scrollView.SetRulerX(scrollRulerX);
- _scrollView.SetRulerY(scrollRulerY);
-
- // Create a horizontal scroll bar in the bottom of scroll view (which is optional)
- _scrollBar = new ScrollBar();
- _scrollBar.ParentOrigin = NDalic.ParentOriginBottomLeft;
- _scrollBar.AnchorPoint = NDalic.AnchorPointTopLeft;
- _scrollBar.SetResizePolicy(ResizePolicyType.FIT_TO_CHILDREN, DimensionType.WIDTH);
- _scrollBar.SetResizePolicy(ResizePolicyType.FILL_TO_PARENT, DimensionType.HEIGHT);
- _scrollBar.Orientation = new Rotation( new Radian( new Degree( 270.0f ) ), Vector3.ZAXIS );
- _scrollBar.SetScrollDirection(ScrollBar.Direction.Horizontal);
- _scrollView.Add(_scrollBar);
-
- // Connect to the OnRelayout signal
- _scrollView.OnRelayoutEvent += OnScrollViewRelayout;
- _scrollView.Touched += OnTouch;
- _scrollView.WheelMoved += Onwheel;
- _scrollView.KeyInputFocusGained += OnKey;
- _text = new TextLabel("View Touch Event Handler Test");
- _text.AnchorPoint = NDalic.AnchorPointTopLeft;
- _text.HorizontalAlignment = "CENTER";
- _text.PointSize = 48.0f;
-
- _scrollView.Add(_text);
- }
- // Callback for _animation finished signal handling
- public void AnimationFinished(object sender, EventArgs e)
- {
- Console.WriteLine("Customized Animation Finished Event handler");
- }
- private void OnKey(object source, View.KeyInputFocusGainedEventArgs e)
- {
- Console.WriteLine("View Keyevent EVENT callback....");
- }
+ // Callback for _animation finished signal handling
+ public void AnimationFinished(object sender, EventArgs e)
+ {
+ Console.WriteLine("Customized Animation Finished Event handler");
+ }
- private bool Onwheel(object source, View.WheelEventArgs e)
- {
- Console.WriteLine("View Wheel EVENT callback....");
- return true;
- }
+ private void OnKey(object source, View.KeyInputFocusGainedEventArgs e)
+ {
+ Console.WriteLine("View Keyevent EVENT callback....");
+ }
- private bool OnTouch(object source, View.TouchEventArgs e)
- {
- Console.WriteLine("View TOUCH EVENT callback....");
-
- // Only animate the _text label when touch down happens
- if( e.Touch.GetState(0) == PointStateType.DOWN )
- {
- Console.WriteLine("Customized Stage Touch event handler");
- // Create a new _animation
- if( _animation )
+ private bool Onwheel(object source, View.WheelEventArgs e)
{
- _animation.Reset();
+ Console.WriteLine("View Wheel EVENT callback....");
+ return true;
}
- _animation = new Animation(1.0f); // 1 second of duration
+ private bool OnTouch(object source, View.TouchEventArgs e)
+ {
+ Console.WriteLine("View TOUCH EVENT callback....");
- _animation.AnimateTo(new Property(_text, Actor.Property.ORIENTATION), new Property.Value(new Rotation( new Radian( new Degree( 180.0f ) ), Vector3.XAXIS )), new AlphaFunction(AlphaFunction.BuiltinFunction.Linear), new TimePeriod(0.0f, 0.5f));
- _animation.AnimateTo(new Property(_text, Actor.Property.ORIENTATION), new Property.Value(new Rotation( new Radian( new Degree( 0.0f ) ), Vector3.XAXIS )), new AlphaFunction(AlphaFunction.BuiltinFunction.Linear), new TimePeriod(0.5f, 0.5f));
+ // Only animate the _text label when touch down happens
+ if (e.Touch.GetState(0) == PointStateType.DOWN)
+ {
+ Console.WriteLine("Customized Window Touch event handler");
+ // Create a new _animation
+ if (_animation)
+ {
+ _animation.Reset();
+ }
- // Connect the signal callback for animaiton finished signal
- _animation.Finished += AnimationFinished;
+ _animation = new Animation(1.0f); // 1 second of duration
- // Play the _animation
- _animation.Play();
- }
- return true;
- }
+ _animation.AnimateTo(new Property(_text, View.Property.ORIENTATION), new Property.Value(new Rotation(new Radian(new Degree(180.0f)), Vector3.XAXIS)), new AlphaFunction(AlphaFunction.BuiltinFunction.Linear), new TimePeriod(0.0f, 0.5f));
+ _animation.AnimateTo(new Property(_text, View.Property.ORIENTATION), new Property.Value(new Rotation(new Radian(new Degree(0.0f)), Vector3.XAXIS)), new AlphaFunction(AlphaFunction.BuiltinFunction.Linear), new TimePeriod(0.5f, 0.5f));
- private void OnScrollViewRelayout(object source, View.OnRelayoutEventArgs e)
- {
- Console.WriteLine("View OnRelayoutEventArgs EVENT callback....");
+ // Connect the signal callback for animaiton finished signal
+ _animation.Finished += AnimationFinished;
- // Set the correct scroll bar size after size negotiation of scroll view is done
- _scrollBar.Size = new Position(0.0f, _scrollView.GetRelayoutSize(DimensionType.WIDTH), 0.0f);
- }
+ // Play the _animation
+ _animation.Play();
+ }
+ return true;
+ }
- public void MainLoop()
- {
- _application.MainLoop ();
- }
+ private void OnScrollViewRelayout(object source, View.OnRelayoutEventArgs e)
+ {
+ Console.WriteLine("View OnRelayoutEventArgs EVENT callback....");
+
+ // Set the correct scroll bar size after size negotiation of scroll view is done
+ _scrollBar.Size = new Position(0.0f, _scrollView.GetRelayoutSize(DimensionType.WIDTH), 0.0f);
+ }
+
+ public void MainLoop()
+ {
+ _application.MainLoop();
+ }
- /// <summary>
- /// The main entry point for the application.
- /// </summary>
- [STAThread]
- static void Main(string[] args)
- {
- Example example = new Example(Application.NewApplication());
- example.MainLoop ();
- }
- }
+ /// <summary>
+ /// The main entry point for the application.
+ /// </summary>
+ [STAThread]
+ static void Main(string[] args)
+ {
+ Example example = new Example(Application.NewApplication());
+ example.MainLoop();
+ }
+ }
}
public void Initialize(object source, NUIApplicationInitEventArgs e)
{
Log("Initialize() is called!");
- Stage stage = Stage.GetCurrent();
- stage.BackgroundColor = Color.White;
- stage.Touch += OnStageTouched;
- stage.Touch += OnStageTouched2;
- stage.Wheel += OnStageWheelEvent;
+ Window window = Window.Instance;
+ window.BackgroundColor = Color.White;
+ window.Touch += OnWindowTouched;
+ window.Touch += OnWindowTouched2;
+ window.Wheel += OnWindowWheelEvent;
- // Add a _text label to the stage
+ // Add a _text label to the window
_text = new TextLabel("Hello Mono World");
_text.ParentOrigin = ParentOrigin.BottomCenter;
_text.AnchorPoint = AnchorPoint.BottomCenter;
_text.HorizontalAlignment = "CENTER";
_text.PointSize = 32.0f;
- stage.Add(_text);
+ window.Add(_text);
_view1 = new View();
_view1.Size = new Vector3(200.0f, 200.0f, 0.0f);
_view1.ParentOrigin = ParentOrigin.Center;
_view1.AnchorPoint = AnchorPoint.Center;
_view1.SetResizePolicy(ResizePolicyType.FIXED, DimensionType.ALL_DIMENSIONS);
- _view1.OnStageEvent += OnStage;
- stage.Add(_view1);
+ _view1.OnWindowEvent += OnWindow;
+ window.Add(_view1);
_view2 = new View();
_view2.BackgroundColor = Color.Red;
_animation.Play();
}
- // Callback for stage touched signal handling
- public void OnStageTouched(object source, Stage.TouchEventArgs e)
+ // Callback for window touched signal handling
+ public void OnWindowTouched(object source, Window.TouchEventArgs e)
{
// Only animate the _text label when touch down happens
if (e.Touch.GetState(0) == PointStateType.DOWN)
{
- Log("OnStageTouched() is called! PointStateType.DOWN came!");
+ Log("OnWindowTouched() is called! PointStateType.DOWN came!");
myCount++;
if (myCount > 1)
{
}
}
- // Callback for stage touched signal handling
- public void OnStageTouched2(object source, Stage.TouchEventArgs e)
+ // Callback for window touched signal handling
+ public void OnWindowTouched2(object source, Window.TouchEventArgs e)
{
- Log("OnStageTouched2() is called!state=" + e.Touch.GetState(0));
+ Log("OnWindowTouched2() is called!state=" + e.Touch.GetState(0));
}
public void OnEventProcessingFinished(object source)
Log("OnEventProcessingFinished() is called!");
}
- public void OnStageWheelEvent(object source, Stage.WheelEventArgs e)
+ public void OnWindowWheelEvent(object source, Window.WheelEventArgs e)
{
- Log("OnStageWheelEvent() is called!");
+ Log("OnWindowWheelEvent() is called!");
}
- public void OnStage(object source, View.OnStageEventArgs e)
+ public void OnWindow(object source, View.OnWindowEventArgs e)
{
- Log("OnStage() is called!");
+ Log("OnWindow() is called!");
}
public void MainLoop()
public void Initialize(object source, NUIApplicationInitEventArgs e)
{
- Stage stage = Stage.Instance;
- stage.BackgroundColor = Color.White;
+ Window window = Window.Instance;
+ window.BackgroundColor = Color.White;
TableView contentLayout = new TableView(4, 1);
contentLayout.Name = ("ContentLayout");
contentLayout.SetCellPadding(new Size2D(0, 5));
contentLayout.BackgroundColor = new Color(0.949f, 0.949f, 0.949f, 1.0f);
- stage.GetDefaultLayer().Add(contentLayout);
+ window.GetDefaultLayer().Add(contentLayout);
_title = new TextLabel("Visuals Example");
_title.Name = "Title";
private void Initialize(object source, NUIApplicationInitEventArgs e)
{
- Stage stage = Stage.Instance;
- stage.BackgroundColor = Color.White;
+ Window window = Window.Instance;
+ window.BackgroundColor = Color.White;
TableView contentLayout = new TableView(14, 1);
contentLayout.Name = "ContentLayout";
contentLayout.SetCellPadding(new Size2D(5, 5));
contentLayout.BackgroundColor = new Color(0.949f, 0.949f, 0.949f, 1.0f);
- stage.GetDefaultLayer().Add(contentLayout);
+ window.GetDefaultLayer().Add(contentLayout);
TextLabel title = new TextLabel("Contacts List with Visuals");
title.Name = "Title";
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, AccessibilityManager.FocusOvershotDirection arg2) {
- NDalicPINVOKE.AccessibilityFocusOvershotSignal_Emit(swigCPtr, Actor.getCPtr(arg1), (int)arg2);
+ public void Emit(View arg1, AccessibilityManager.FocusOvershotDirection arg2) {
+ NDalicPINVOKE.AccessibilityFocusOvershotSignal_Emit(swigCPtr, View.getCPtr(arg1), (int)arg2);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
*/
public class FocusChangedEventArgs : EventArgs
{
- private Actor _actorCurrent;
- private Actor _actorNext;
+ private View _viewCurrent;
+ private View _viewNext;
- public Actor ActorCurrent
+ public View ViewCurrent
{
get
{
- return _actorCurrent;
+ return _viewCurrent;
}
set
{
- _actorCurrent = value;
+ _viewCurrent = value;
}
}
- public Actor ActorNext
+ public View ViewNext
{
get
{
- return _actorNext;
+ return _viewNext;
}
set
{
- _actorNext = value;
+ _viewNext = value;
}
}
}
/**
- * @brief Event arguments that passed via FocusedActorActivated signal
+ * @brief Event arguments that passed via FocusedViewActivated signal
*
*/
- public class FocusedActorActivatedEventArgs : EventArgs
+ public class FocusedViewActivatedEventArgs : EventArgs
{
- private Actor _actor;
+ private View _view;
- public Actor Actor
+ public View View
{
get
{
- return _actor;
+ return _view;
}
set
{
- _actor = value;
+ _view = value;
}
}
}
*/
public class FocusOvershotEventArgs : EventArgs
{
- private Actor _currentFocusedActor;
+ private View _currentFocusedView;
private AccessibilityManager.FocusOvershotDirection _focusOvershotDirection;
- public Actor CurrentFocusedActor
+ public View CurrentFocusedView
{
get
{
- return _currentFocusedActor;
+ return _currentFocusedView;
}
set
{
- _currentFocusedActor = value;
+ _currentFocusedView = value;
}
}
private FocusChangedEventCallbackDelegate _accessibilityManagerFocusChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void FocusedActorActivatedEventCallbackDelegate(IntPtr actor);
- private DaliEventHandler<object,FocusedActorActivatedEventArgs> _accessibilityManagerFocusedActorActivatedEventHandler;
- private FocusedActorActivatedEventCallbackDelegate _accessibilityManagerFocusedActorActivatedEventCallbackDelegate;
+ private delegate void FocusedViewActivatedEventCallbackDelegate(IntPtr actor);
+ private DaliEventHandler<object,FocusedViewActivatedEventArgs> _accessibilityManagerFocusedViewActivatedEventHandler;
+ private FocusedViewActivatedEventCallbackDelegate _accessibilityManagerFocusedViewActivatedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction);
+ private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedView, AccessibilityManager.FocusOvershotDirection direction);
private DaliEventHandler<object,FocusOvershotEventArgs> _accessibilityManagerFocusOvershotEventHandler;
private FocusOvershotEventCallbackDelegate _accessibilityManagerFocusOvershotEventCallbackDelegate;
FocusChangedEventArgs e = new FocusChangedEventArgs();
// Populate all members of "e" (FocusChangedEventArgs) with real data
- e.ActorCurrent = Actor.GetActorFromPtr(actor1);
- e.ActorNext = Actor.GetActorFromPtr(actor2);
+ e.ViewCurrent = View.GetViewFromPtr(actor1);
+ e.ViewNext = View.GetViewFromPtr(actor2);
if (_accessibilityManagerFocusChangedEventHandler != null)
{
}
}
- public event DaliEventHandler<object,FocusedActorActivatedEventArgs> FocusedActorActivated
+ public event DaliEventHandler<object,FocusedViewActivatedEventArgs> FocusedViewActivated
{
add
{
lock(this)
{
// Restricted to only one listener
- if (_accessibilityManagerFocusedActorActivatedEventHandler == null)
+ if (_accessibilityManagerFocusedViewActivatedEventHandler == null)
{
- _accessibilityManagerFocusedActorActivatedEventHandler += value;
+ _accessibilityManagerFocusedViewActivatedEventHandler += value;
- _accessibilityManagerFocusedActorActivatedEventCallbackDelegate = new FocusedActorActivatedEventCallbackDelegate(OnFocusedActorActivated);
- this.FocusedActorActivatedSignal().Connect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
+ _accessibilityManagerFocusedViewActivatedEventCallbackDelegate = new FocusedViewActivatedEventCallbackDelegate(OnFocusedViewActivated);
+ this.FocusedViewActivatedSignal().Connect(_accessibilityManagerFocusedViewActivatedEventCallbackDelegate);
}
}
}
{
lock(this)
{
- if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
+ if (_accessibilityManagerFocusedViewActivatedEventHandler != null)
{
- this.FocusedActorActivatedSignal().Disconnect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
+ this.FocusedViewActivatedSignal().Disconnect(_accessibilityManagerFocusedViewActivatedEventCallbackDelegate);
}
- _accessibilityManagerFocusedActorActivatedEventHandler -= value;
+ _accessibilityManagerFocusedViewActivatedEventHandler -= value;
}
}
}
- // Callback for AccessibilityManager FocusedActorActivatedSignal
- private void OnFocusedActorActivated(IntPtr actor)
+ // Callback for AccessibilityManager FocusedViewActivatedSignal
+ private void OnFocusedViewActivated(IntPtr actor)
{
- FocusedActorActivatedEventArgs e = new FocusedActorActivatedEventArgs();
+ FocusedViewActivatedEventArgs e = new FocusedViewActivatedEventArgs();
- // Populate all members of "e" (FocusedActorActivatedEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
+ // Populate all members of "e" (FocusedViewActivatedEventArgs) with real data
+ e.View = View.GetViewFromPtr(actor);
- if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
+ if (_accessibilityManagerFocusedViewActivatedEventHandler != null)
{
//here we send all data to user event handlers
- _accessibilityManagerFocusedActorActivatedEventHandler(this, e);
+ _accessibilityManagerFocusedViewActivatedEventHandler(this, e);
}
}
}
// Callback for AccessibilityManager FocusOvershotSignal
- private void OnFocusOvershot(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction)
+ private void OnFocusOvershot(IntPtr currentFocusedView, AccessibilityManager.FocusOvershotDirection direction)
{
FocusOvershotEventArgs e = new FocusOvershotEventArgs();
// Populate all members of "e" (FocusOvershotEventArgs) with real data
- e.CurrentFocusedActor = Actor.GetActorFromPtr(currentFocusedActor);
+ e.CurrentFocusedView = View.GetViewFromPtr(currentFocusedView);
e.FocusOvershotDirection = direction;
if (_accessibilityManagerFocusOvershotEventHandler != null)
return ret;
}
- public void SetAccessibilityAttribute(Actor actor, AccessibilityManager.AccessibilityAttribute type, string text) {
- NDalicPINVOKE.AccessibilityManager_SetAccessibilityAttribute(swigCPtr, Actor.getCPtr(actor), (int)type, text);
+ public void SetAccessibilityAttribute(View view, AccessibilityManager.AccessibilityAttribute type, string text) {
+ NDalicPINVOKE.AccessibilityManager_SetAccessibilityAttribute(swigCPtr, View.getCPtr(view), (int)type, text);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public string GetAccessibilityAttribute(Actor actor, AccessibilityManager.AccessibilityAttribute type) {
- string ret = NDalicPINVOKE.AccessibilityManager_GetAccessibilityAttribute(swigCPtr, Actor.getCPtr(actor), (int)type);
+ public string GetAccessibilityAttribute(View view, AccessibilityManager.AccessibilityAttribute type) {
+ string ret = NDalicPINVOKE.AccessibilityManager_GetAccessibilityAttribute(swigCPtr, View.getCPtr(view), (int)type);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public void SetFocusOrder(Actor actor, uint order) {
- NDalicPINVOKE.AccessibilityManager_SetFocusOrder(swigCPtr, Actor.getCPtr(actor), order);
+ public void SetFocusOrder(View view, uint order) {
+ NDalicPINVOKE.AccessibilityManager_SetFocusOrder(swigCPtr, View.getCPtr(view), order);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public uint GetFocusOrder(Actor actor) {
- uint ret = NDalicPINVOKE.AccessibilityManager_GetFocusOrder(swigCPtr, Actor.getCPtr(actor));
+ public uint GetFocusOrder(View view) {
+ uint ret = NDalicPINVOKE.AccessibilityManager_GetFocusOrder(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public Actor GetActorByFocusOrder(uint order) {
- Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetActorByFocusOrder(swigCPtr, order), true);
+ public View GetViewByFocusOrder(uint order) {
+ View ret = new View(NDalicPINVOKE.AccessibilityManager_GetActorByFocusOrder(swigCPtr, order), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public bool SetCurrentFocusActor(Actor actor) {
- bool ret = NDalicPINVOKE.AccessibilityManager_SetCurrentFocusActor(swigCPtr, Actor.getCPtr(actor));
+ public bool SetCurrentFocusView(View view) {
+ bool ret = NDalicPINVOKE.AccessibilityManager_SetCurrentFocusActor(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor GetCurrentFocusActor() {
- Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusActor(swigCPtr), true);
+ public View GetCurrentFocusView() {
+ View ret = new View(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor GetCurrentFocusGroup() {
- Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusGroup(swigCPtr), true);
+ public View GetCurrentFocusGroup() {
+ View ret = new View(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusGroup(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetFocusGroup(Actor actor, bool isFocusGroup) {
- NDalicPINVOKE.AccessibilityManager_SetFocusGroup(swigCPtr, Actor.getCPtr(actor), isFocusGroup);
+ public void SetFocusGroup(View view, bool isFocusGroup) {
+ NDalicPINVOKE.AccessibilityManager_SetFocusGroup(swigCPtr, View.getCPtr(view), isFocusGroup);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public bool IsFocusGroup(Actor actor) {
- bool ret = NDalicPINVOKE.AccessibilityManager_IsFocusGroup(swigCPtr, Actor.getCPtr(actor));
+ public bool IsFocusGroup(View view) {
+ bool ret = NDalicPINVOKE.AccessibilityManager_IsFocusGroup(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public void SetFocusIndicatorActor(Actor indicator) {
- NDalicPINVOKE.AccessibilityManager_SetFocusIndicatorActor(swigCPtr, Actor.getCPtr(indicator));
+ public void SetFocusIndicatorView(View indicator) {
+ NDalicPINVOKE.AccessibilityManager_SetFocusIndicatorActor(swigCPtr, View.getCPtr(indicator));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetFocusIndicatorActor() {
- Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetFocusIndicatorActor(swigCPtr), true);
+ public View GetFocusIndicatorView() {
+ View ret = new View(NDalicPINVOKE.AccessibilityManager_GetFocusIndicatorActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor GetFocusGroup(Actor actor) {
- Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetFocusGroup(swigCPtr, Actor.getCPtr(actor)), true);
+ public View GetFocusGroup(View view) {
+ View ret = new View(NDalicPINVOKE.AccessibilityManager_GetFocusGroup(swigCPtr, View.getCPtr(view)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public ActorSignal FocusedActorActivatedSignal() {
- ActorSignal ret = new ActorSignal(NDalicPINVOKE.AccessibilityManager_FocusedActorActivatedSignal(swigCPtr), false);
+ public ViewSignal FocusedViewActivatedSignal() {
+ ViewSignal ret = new ViewSignal(NDalicPINVOKE.AccessibilityManager_FocusedActorActivatedSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+++ /dev/null
-/** Copyright (c) 2017 Samsung Electronics Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*
-*/
-// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.10
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Dali {
-
- using System;
- using System.Runtime.InteropServices;
-
-public class Actor : Handle {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
- internal Actor(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Actor_SWIGUpcast(cPtr), cMemoryOwn) {
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
-
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Actor obj) {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
-
- ~Actor() {
- DisposeQueue.Instance.Add(this);
- }
-
- public override void Dispose() {
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_Actor(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- base.Dispose();
- }
- }
-
-
-
- public static Actor GetActorFromPtr(global::System.IntPtr cPtr) {
- Actor ret = new Actor(cPtr, false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public IntPtr GetPtrfromActor ()
- {
- return (IntPtr)swigCPtr;
- }
-
- public Position CurrentPosition
- {
- get
- {
- return GetCurrentPosition();
- }
- }
-
- public Size2D Size2D
- {
- get
- {
- Size temp = new Size(0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.SIZE).Get( temp );
- return new Size2D(temp);
- }
- set
- {
- SetProperty( Actor.Property.SIZE, new Dali.Property.Value( new Size(value) ) );
- }
- }
-
- public Size CurrentSize
- {
- get
- {
- return GetCurrentSize();
- }
- }
-
- public Actor Parent
- {
- get
- {
- return GetParent();
- }
- }
-
- public bool Visibility
- {
- get
- {
- return IsVisible();
- }
- }
-
- public float Opacity
- {
- get
- {
- float temp = 0;
- GetProperty( Actor.Property.OPACITY ).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.OPACITY, new Dali.Property.Value( value ) );
- }
- }
-
- public Position2D Position2D
- {
- get
- {
- Position temp = new Position(0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.POSITION).Get( temp );
- return new Position2D(temp);
- }
- set
- {
- SetProperty( Actor.Property.POSITION, new Dali.Property.Value( new Position(value) ) );
- }
- }
-
- public Vector2 ScreenPosition
- {
- get
- {
- Vector2 temp = new Vector2( 0.0f, 0.0f );
- GetProperty( Actor.Property.SCREEN_POSITION ).Get( temp );
- return temp;
- }
- }
-
- protected bool PositionUsesAnchorPoint
- {
- get
- {
- bool temp = false;
- GetProperty( Actor.Property.POSITION_USES_ANCHOR_POINT ).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.POSITION_USES_ANCHOR_POINT, new Dali.Property.Value( value ) );
- }
- }
-
- public bool StateFocusEnable
- {
- get
- {
- return IsKeyboardFocusable();
- }
- set
- {
- SetKeyboardFocusable(value);
- }
- }
-
- public bool IsOnStage
- {
- get
- {
- return OnStage();
- }
- }
-
- public int SiblingOrder
- {
- get
- {
- int temp = 0;
- GetProperty( Actor.Property.SIBLING_ORDER ).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SIBLING_ORDER, new Dali.Property.Value( value ) );
- }
- }
-
- public void Show()
- {
- SetVisible(true);
- }
-
- public void Hide()
- {
- SetVisible(false);
- }
-
- public void Raise()
- {
- NDalicPINVOKE.Raise(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Lower()
- {
- NDalicPINVOKE.Lower(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void RaiseToTop()
- {
- NDalicPINVOKE.RaiseToTop(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void LowerToBottom()
- {
- NDalicPINVOKE.LowerToBottom(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void RaiseAbove(Actor target)
- {
- NDalicPINVOKE.RaiseAbove(swigCPtr, Actor.getCPtr(target));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void LowerBelow(Actor target)
- {
- NDalicPINVOKE.RaiseAbove(swigCPtr, Actor.getCPtr(target));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
-
- public class Property : global::System.IDisposable {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- protected bool swigCMemOwn;
-
- internal Property(global::System.IntPtr cPtr, bool cMemoryOwn) {
- swigCMemOwn = cMemoryOwn;
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
-
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj) {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
-
- ~Property() {
- Dispose();
- }
-
- public virtual void Dispose() {
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_Actor_Property(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-
- public static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
- public static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
- public static readonly int SCREEN_POSITION = NDalicManualPINVOKE.Actor_Property_SCREEN_POSITION_get();
- public static readonly int POSITION_USES_ANCHOR_POINT = NDalicManualPINVOKE.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
-
- public Property() : this(NDalicPINVOKE.new_Actor_Property(), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
- public static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
- public static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
- public static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
- public static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
- public static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
- public static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
- public static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
- public static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
- public static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
- public static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
- public static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
- public static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
- public static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
- public static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
- public static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
- public static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
- public static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
- public static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
- public static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
- public static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
- public static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
- public static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
- public static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
- public static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
- public static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
- public static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
- public static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
- public static readonly int COLOR = NDalicPINVOKE.Actor_Property_COLOR_get();
- public static readonly int COLOR_RED = NDalicPINVOKE.Actor_Property_COLOR_RED_get();
- public static readonly int COLOR_GREEN = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();
- public static readonly int COLOR_BLUE = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();
- public static readonly int COLOR_ALPHA = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();
- public static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
- public static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
- public static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
- public static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
- public static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
- public static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
- public static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
- public static readonly int COLOR_MODE = NDalicPINVOKE.Actor_Property_COLOR_MODE_get();
- public static readonly int POSITION_INHERITANCE = NDalicPINVOKE.Actor_Property_POSITION_INHERITANCE_get();
- public static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
- public static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
- public static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
- public static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
- public static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
- public static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
- public static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
- public static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
- public static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
- public static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
- public static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
- public static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
-
- }
-
- public Actor () : this (NDalicPINVOKE.Actor_New(), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-
- }
- public new static Actor DownCast(BaseHandle handle) {
- Actor ret = new Actor(NDalicPINVOKE.Actor_DownCast(BaseHandle.getCPtr(handle)), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Actor(Actor copy) : this(NDalicPINVOKE.new_Actor__SWIG_1(Actor.getCPtr(copy)), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Actor Assign(Actor rhs) {
- Actor ret = new Actor(NDalicPINVOKE.Actor_Assign(swigCPtr, Actor.getCPtr(rhs)), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public string GetName() {
- string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetName(string name) {
- NDalicPINVOKE.Actor_SetName(swigCPtr, name);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public uint GetId() {
- uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public bool IsRoot() {
- bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public bool OnStage() {
- bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public bool IsLayer() {
- bool ret = NDalicPINVOKE.Actor_IsLayer(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Layer GetLayer() {
- Layer ret = new Layer(NDalicPINVOKE.Actor_GetLayer(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void Add(Actor child) {
- NDalicPINVOKE.Actor_Add(swigCPtr, Actor.getCPtr(child));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Remove(Actor child) {
- NDalicPINVOKE.Actor_Remove(swigCPtr, Actor.getCPtr(child));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Unparent() {
- NDalicPINVOKE.Actor_Unparent(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public uint GetChildCount() {
- uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Actor GetChildAt(uint index) {
- Actor ret = new Actor(NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Actor FindChildByName(string actorName) {
- Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, actorName), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Actor FindChildById(uint id) {
- Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Actor GetParent() {
- Actor ret = new Actor(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetParentOrigin(Vector3 origin) {
- NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector3 GetCurrentParentOrigin() {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetAnchorPoint(Vector3 anchorPoint) {
- NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector3 GetCurrentAnchorPoint() {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetSize(float width, float height) {
- NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetSize(float width, float height, float depth) {
- NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetSize(Vector2 size) {
- NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetSize(Vector3 size) {
- NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector3 GetTargetSize() {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Vector3 GetCurrentSize() {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Vector3 GetNaturalSize() {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetPosition(float x, float y) {
- NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetPosition(float x, float y, float z) {
- NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetPosition(Vector3 position) {
- NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetX(float x) {
- NDalicPINVOKE.Actor_SetX(swigCPtr, x);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetY(float y) {
- NDalicPINVOKE.Actor_SetY(swigCPtr, y);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetZ(float z) {
- NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void TranslateBy(Vector3 distance) {
- NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector3 GetCurrentPosition() {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Vector3 GetCurrentWorldPosition() {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetInheritPosition(bool inherit) {
- NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public PositionInheritanceMode GetPositionInheritanceMode() {
- PositionInheritanceMode ret = (PositionInheritanceMode)NDalicPINVOKE.Actor_GetPositionInheritanceMode(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public bool IsPositionInherited() {
- bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetOrientation(Degree angle, Vector3 axis) {
- NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetOrientation(Radian angle, Vector3 axis) {
- NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetOrientation(Rotation orientation) {
- NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void RotateBy(Degree angle, Vector3 axis) {
- NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void RotateBy(Radian angle, Vector3 axis) {
- NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void RotateBy(Rotation relativeRotation) {
- NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Rotation GetCurrentOrientation() {
- Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetInheritOrientation(bool inherit) {
- NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public bool IsOrientationInherited() {
- bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Rotation GetCurrentWorldOrientation() {
- Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetScale(float scale) {
- NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetScale(float scaleX, float scaleY, float scaleZ) {
- NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetScale(Vector3 scale) {
- NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void ScaleBy(Vector3 relativeScale) {
- NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector3 GetCurrentScale() {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Vector3 GetCurrentWorldScale() {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetInheritScale(bool inherit) {
- NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public bool IsScaleInherited() {
- bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Matrix GetCurrentWorldMatrix() {
- Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetVisible(bool visible) {
- NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public bool IsVisible() {
- bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetOpacity(float opacity) {
- NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public float GetCurrentOpacity() {
- float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetColor(Vector4 color) {
- NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector4 GetCurrentColor() {
- Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetColorMode(ColorMode colorMode) {
- NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public ColorMode GetColorMode() {
- ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Vector4 GetCurrentWorldColor() {
- Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetDrawMode(DrawModeType drawMode) {
- NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public DrawModeType GetDrawMode() {
- DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetSensitive(bool sensitive) {
- NDalicPINVOKE.Actor_SetSensitive(swigCPtr, sensitive);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public bool IsSensitive() {
- bool ret = NDalicPINVOKE.Actor_IsSensitive(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY) {
- bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetLeaveRequired(bool required) {
- NDalicPINVOKE.Actor_SetLeaveRequired(swigCPtr, required);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public bool GetLeaveRequired() {
- bool ret = NDalicPINVOKE.Actor_GetLeaveRequired(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetKeyboardFocusable(bool focusable) {
- NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public bool IsKeyboardFocusable() {
- bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetResizePolicy(ResizePolicyType policy, DimensionType dimension) {
- NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public ResizePolicyType GetResizePolicy(DimensionType dimension) {
- ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetSizeScalePolicy(SizeScalePolicyType policy) {
- NDalicPINVOKE.Actor_SetSizeScalePolicy(swigCPtr, (int)policy);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public SizeScalePolicyType GetSizeScalePolicy() {
- SizeScalePolicyType ret = (SizeScalePolicyType)NDalicPINVOKE.Actor_GetSizeScalePolicy(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetSizeModeFactor(Vector3 factor) {
- NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector3 GetSizeModeFactor() {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public float GetHeightForWidth(float width) {
- float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public float GetWidthForHeight(float height) {
- float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public float GetRelayoutSize(DimensionType dimension) {
- float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetPadding(PaddingType padding) {
- NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void GetPadding(PaddingType paddingOut) {
- NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetMinimumSize(Vector2 size) {
- NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector2 GetMinimumSize() {
- Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetMaximumSize(Vector2 size) {
- NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector2 GetMaximumSize() {
- Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public int GetHierarchyDepth() {
- int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public uint AddRenderer(Renderer renderer) {
- uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public uint GetRendererCount() {
- uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Renderer GetRendererAt(uint index) {
- Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void RemoveRenderer(Renderer renderer) {
- NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void RemoveRenderer(uint index) {
- NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public SWIGTYPE_p_Dali__SignalT_bool_fDali__Actor_Dali__TouchEvent_const_RF_t TouchedSignal() {
- SWIGTYPE_p_Dali__SignalT_bool_fDali__Actor_Dali__TouchEvent_const_RF_t ret = new SWIGTYPE_p_Dali__SignalT_bool_fDali__Actor_Dali__TouchEvent_const_RF_t(NDalicPINVOKE.Actor_TouchedSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public ActorTouchDataSignal TouchSignal() {
- ActorTouchDataSignal ret = new ActorTouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public ActorHoverSignal HoveredSignal() {
- ActorHoverSignal ret = new ActorHoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public ActorWheelSignal WheelEventSignal() {
- ActorWheelSignal ret = new ActorWheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public ActorSignal OnStageSignal() {
- ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public ActorSignal OffStageSignal() {
- ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public ActorSignal OnRelayoutSignal() {
- ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Vector3 ParentOrigin
- {
- get
- {
- Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.PARENT_ORIGIN).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.PARENT_ORIGIN, new Dali.Property.Value( value ) );
- }
- }
- public float ParentOriginX
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.PARENT_ORIGIN_X).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.PARENT_ORIGIN_X, new Dali.Property.Value( value ) );
- }
- }
- public float ParentOriginY
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.PARENT_ORIGIN_Y).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.PARENT_ORIGIN_Y, new Dali.Property.Value( value ) );
- }
- }
- public float ParentOriginZ
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.PARENT_ORIGIN_Z).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.PARENT_ORIGIN_Z, new Dali.Property.Value( value ) );
- }
- }
- public Vector3 AnchorPoint
- {
- get
- {
- Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.ANCHOR_POINT).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.ANCHOR_POINT, new Dali.Property.Value( value ) );
- }
- }
- public float AnchorPointX
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.ANCHOR_POINT_X).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.ANCHOR_POINT_X, new Dali.Property.Value( value ) );
- }
- }
- public float AnchorPointY
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.ANCHOR_POINT_Y).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.ANCHOR_POINT_Y, new Dali.Property.Value( value ) );
- }
- }
- public float AnchorPointZ
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.ANCHOR_POINT_Z).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.ANCHOR_POINT_Z, new Dali.Property.Value( value ) );
- }
- }
- public Vector3 Size
- {
- get
- {
- Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.SIZE).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SIZE, new Dali.Property.Value( value ) );
- }
- }
- public float SizeWidth
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.SIZE_WIDTH).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SIZE_WIDTH, new Dali.Property.Value( value ) );
- }
- }
- public float SizeHeight
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.SIZE_HEIGHT).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SIZE_HEIGHT, new Dali.Property.Value( value ) );
- }
- }
- public float SizeDepth
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.SIZE_DEPTH).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SIZE_DEPTH, new Dali.Property.Value( value ) );
- }
- }
- public Vector3 Position
- {
- get
- {
- Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.POSITION).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.POSITION, new Dali.Property.Value( value ) );
- }
- }
- public float PositionX
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.POSITION_X).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.POSITION_X, new Dali.Property.Value( value ) );
- }
- }
- public float PositionY
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.POSITION_Y).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.POSITION_Y, new Dali.Property.Value( value ) );
- }
- }
- public float PositionZ
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.POSITION_Z).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.POSITION_Z, new Dali.Property.Value( value ) );
- }
- }
- public Vector3 WorldPosition
- {
- get
- {
- Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.WORLD_POSITION).Get( temp );
- return temp;
- }
-} public float WorldPositionX
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.WORLD_POSITION_X).Get( ref temp );
- return temp;
- }
-} public float WorldPositionY
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.WORLD_POSITION_Y).Get( ref temp );
- return temp;
- }
-} public float WorldPositionZ
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.WORLD_POSITION_Z).Get( ref temp );
- return temp;
- }
-} public Rotation Orientation
- {
- get
- {
- Rotation temp = new Rotation();
- GetProperty( Actor.Property.ORIENTATION).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.ORIENTATION, new Dali.Property.Value( value ) );
- }
- }
- public Rotation WorldOrientation
- {
- get
- {
- Rotation temp = new Rotation();
- GetProperty( Actor.Property.WORLD_ORIENTATION).Get( temp );
- return temp;
- }
-} public Vector3 Scale
- {
- get
- {
- Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.SCALE).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SCALE, new Dali.Property.Value( value ) );
- }
- }
- public float ScaleX
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.SCALE_X).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SCALE_X, new Dali.Property.Value( value ) );
- }
- }
- public float ScaleY
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.SCALE_Y).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SCALE_Y, new Dali.Property.Value( value ) );
- }
- }
- public float ScaleZ
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.SCALE_Z).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SCALE_Z, new Dali.Property.Value( value ) );
- }
- }
- public Vector3 WorldScale
- {
- get
- {
- Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.WORLD_SCALE).Get( temp );
- return temp;
- }
-} public bool Visible
- {
- get
- {
- bool temp = false;
- GetProperty( Actor.Property.VISIBLE).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.VISIBLE, new Dali.Property.Value( value ) );
- }
- }
- public float ColorRed
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.COLOR_RED).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.COLOR_RED, new Dali.Property.Value( value ) );
- }
- }
- public float ColorGreen
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.COLOR_GREEN).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.COLOR_GREEN, new Dali.Property.Value( value ) );
- }
- }
- public float ColorBlue
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.COLOR_BLUE).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.COLOR_BLUE, new Dali.Property.Value( value ) );
- }
- }
- public float ColorAlpha
- {
- get
- {
- float temp = 0.0f;
- GetProperty( Actor.Property.COLOR_ALPHA).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.COLOR_ALPHA, new Dali.Property.Value( value ) );
- }
- }
- public Vector4 WorldColor
- {
- get
- {
- Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.WORLD_COLOR).Get( temp );
- return temp;
- }
-} public Matrix WorldMatrix
- {
- get
- {
- Matrix temp = new Matrix();
- GetProperty( Actor.Property.WORLD_MATRIX).Get( temp );
- return temp;
- }
-} public string Name
- {
- get
- {
- string temp;
- GetProperty( Actor.Property.NAME).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.NAME, new Dali.Property.Value( value ) );
- }
- }
- public bool Sensitive
- {
- get
- {
- bool temp = false;
- GetProperty( Actor.Property.SENSITIVE).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SENSITIVE, new Dali.Property.Value( value ) );
- }
- }
- public bool LeaveRequired
- {
- get
- {
- bool temp = false;
- GetProperty( Actor.Property.LEAVE_REQUIRED).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.LEAVE_REQUIRED, new Dali.Property.Value( value ) );
- }
- }
- public bool InheritOrientation
- {
- get
- {
- bool temp = false;
- GetProperty( Actor.Property.INHERIT_ORIENTATION).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.INHERIT_ORIENTATION, new Dali.Property.Value( value ) );
- }
- }
- public bool InheritScale
- {
- get
- {
- bool temp = false;
- GetProperty( Actor.Property.INHERIT_SCALE).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.INHERIT_SCALE, new Dali.Property.Value( value ) );
- }
- }
- public string ColorMode
- {
- get
- {
- string temp;
- GetProperty( Actor.Property.COLOR_MODE).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.COLOR_MODE, new Dali.Property.Value( value ) );
- }
- }
- public string PositionInheritance
- {
- get
- {
- string temp;
- GetProperty( Actor.Property.POSITION_INHERITANCE).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.POSITION_INHERITANCE, new Dali.Property.Value( value ) );
- }
- }
- public string DrawMode
- {
- get
- {
- string temp;
- GetProperty( Actor.Property.DRAW_MODE).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.DRAW_MODE, new Dali.Property.Value( value ) );
- }
- }
- public Vector3 SizeModeFactor
- {
- get
- {
- Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.SIZE_MODE_FACTOR).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SIZE_MODE_FACTOR, new Dali.Property.Value( value ) );
- }
- }
- public string WidthResizePolicy
- {
- get
- {
- string temp;
- GetProperty( Actor.Property.WIDTH_RESIZE_POLICY).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.WIDTH_RESIZE_POLICY, new Dali.Property.Value( value ) );
- }
- }
- public string HeightResizePolicy
- {
- get
- {
- string temp;
- GetProperty( Actor.Property.HEIGHT_RESIZE_POLICY).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.HEIGHT_RESIZE_POLICY, new Dali.Property.Value( value ) );
- }
- }
- public string SizeScalePolicy
- {
- get
- {
- string temp;
- GetProperty( Actor.Property.SIZE_SCALE_POLICY).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.SIZE_SCALE_POLICY, new Dali.Property.Value( value ) );
- }
- }
- public bool WidthForHeight
- {
- get
- {
- bool temp = false;
- GetProperty( Actor.Property.WIDTH_FOR_HEIGHT).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.WIDTH_FOR_HEIGHT, new Dali.Property.Value( value ) );
- }
- }
- public bool HeightForWidth
- {
- get
- {
- bool temp = false;
- GetProperty( Actor.Property.HEIGHT_FOR_WIDTH).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.HEIGHT_FOR_WIDTH, new Dali.Property.Value( value ) );
- }
- }
- public Vector4 Padding
- {
- get
- {
- Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
- GetProperty( Actor.Property.PADDING).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.PADDING, new Dali.Property.Value( value ) );
- }
- }
- public Vector2 MinimumSize
- {
- get
- {
- Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( Actor.Property.MINIMUM_SIZE).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.MINIMUM_SIZE, new Dali.Property.Value( value ) );
- }
- }
- public Vector2 MaximumSize
- {
- get
- {
- Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( Actor.Property.MAXIMUM_SIZE).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.MAXIMUM_SIZE, new Dali.Property.Value( value ) );
- }
- }
- public bool InheritPosition
- {
- get
- {
- bool temp = false;
- GetProperty( Actor.Property.INHERIT_POSITION).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.INHERIT_POSITION, new Dali.Property.Value( value ) );
- }
- }
- public string ClippingMode
- {
- get
- {
- string temp;
- GetProperty( Actor.Property.CLIPPING_MODE).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.CLIPPING_MODE, new Dali.Property.Value( value ) );
- }
- }
-
-}
-
-}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
* limitations under the License.
*
*/
-// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.10
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
namespace Dali {
-public class Handle : BaseHandle {
+public class Animatable : BaseHandle {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- internal Handle(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Handle_SWIGUpcast(cPtr), cMemoryOwn) {
+ internal Animatable(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Handle_SWIGUpcast(cPtr), cMemoryOwn) {
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Handle obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Animatable obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~Handle() {
+ ~Animatable() {
DisposeQueue.Instance.Add(this);
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
- public Handle () : this (NDalicPINVOKE.Handle_New(), true) {
+ public Animatable () : this (NDalicPINVOKE.Handle_New(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Handle(Handle handle) : this(NDalicPINVOKE.new_Handle__SWIG_1(Handle.getCPtr(handle)), true) {
+ public Animatable(Animatable handle) : this(NDalicPINVOKE.new_Handle__SWIG_1(Animatable.getCPtr(handle)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Handle Assign(Handle rhs) {
- Handle ret = new Handle(NDalicPINVOKE.Handle_Assign(swigCPtr, Handle.getCPtr(rhs)), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public static Handle DownCast(BaseHandle handle) {
- Handle ret = new Handle(NDalicPINVOKE.Handle_DownCast(BaseHandle.getCPtr(handle)), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public bool Supports(Handle.Capability capability) {
+ public bool Supports(Animatable.Capability capability) {
bool ret = NDalicPINVOKE.Handle_Supports(swigCPtr, (int)capability);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
return ret;
}
- public void SetProperty(int index, Property.Value propertyValue) {
- NDalicPINVOKE.Handle_SetProperty(swigCPtr, index, Property.Value.getCPtr(propertyValue));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ public void SetProperty(int index, Property.Value propertyValue)
+ {
+ Dali.Object.SetProperty( swigCPtr, index, propertyValue );
}
public int RegisterProperty(string name, Property.Value propertyValue) {
return ret;
}
- public Property.Value GetProperty(int index) {
- Property.Value ret = new Property.Value(NDalicPINVOKE.Handle_GetProperty(swigCPtr, index), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ public Property.Value GetProperty(int index)
+ {
+ Property.Value ret = Dali.Object.GetProperty( swigCPtr, index );
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
// the SWIG interface file instead.
//------------------------------------------------------------------------------
-namespace Dali {
+namespace Dali
+{
-using System;
-using System.Runtime.InteropServices;
+ using System;
+ using System.Runtime.InteropServices;
-public class Animation : BaseHandle {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
- internal Animation(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Animation_SWIGUpcast(cPtr), cMemoryOwn) {
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
+ public class Animation : BaseHandle
+ {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Animation obj) {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
+ internal Animation(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Animation_SWIGUpcast(cPtr), cMemoryOwn)
+ {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
- ~Animation() {
- DisposeQueue.Instance.Add(this);
- }
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Animation obj)
+ {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
- public override void Dispose() {
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
+ ~Animation()
+ {
+ DisposeQueue.Instance.Add(this);
+ }
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_Animation(swigCPtr);
+ public override void Dispose()
+ {
+ if (!Window.IsInstalled())
+ {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
+ lock (this)
+ {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero)
+ {
+ if (swigCMemOwn)
+ {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_Animation(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ base.Dispose();
+ }
}
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- base.Dispose();
- }
- }
- private EventCallbackDelegateType1<IntPtr> _animationFinishedEventCallbackDelegate;
- private event EventHandler _animationFinishedEventHandler;
+ private EventCallbackDelegateType1<IntPtr> _animationFinishedEventCallbackDelegate;
+
+ private event EventHandler _animationFinishedEventHandler;
- /**
+ /**
* @brief Event for Finished signal which can be used to subscribe/unsubscribe the event handler
* Finished signal is emitted when an Animation's animations have finished.
*/
- public event EventHandler Finished
- {
- add
- {
- lock(this)
- {
- _animationFinishedEventHandler += value;
- _animationFinishedEventCallbackDelegate = OnFinished;
- this.FinishedSignal().Connect(_animationFinishedEventCallbackDelegate);
- }
- }
- remove
- {
- lock(this)
- {
- if (_animationFinishedEventHandler != null)
- {
- this.FinishedSignal().Disconnect(_animationFinishedEventCallbackDelegate);
- }
- _animationFinishedEventHandler -= value;
- }
- }
- }
-
- // Callback for Animation FinishedSignal
- private void OnFinished(IntPtr data)
- {
- if (_animationFinishedEventHandler != null)
- {
- //here we send all data to user event handlers
- _animationFinishedEventHandler(this, null);
- }
- }
-
- public static Animation GetAnimationFromPtr(global::System.IntPtr cPtr) {
- Animation ret = new Animation(cPtr, false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- private float MilliSecondsToSeconds( int millisec )
- {
- return (float)millisec / 1000.0f;
- }
-
- private int SecondsToMilliSeconds( float sec )
- {
- return (int)( sec * 1000 );
- }
-
- public int Duration
- {
- set
- {
- SetDuration( MilliSecondsToSeconds( value ) );
- }
- get
- {
- return SecondsToMilliSeconds( GetDuration() );
- }
- }
-
- public AlphaFunction DefaultAlphaFunction
- {
- set
- {
- SetDefaultAlphaFunction(value);
- }
- get
- {
- AlphaFunction ret = GetDefaultAlphaFunction();
- return ret;
- }
- }
-
- public Animation.State Status
- {
- get
- {
- return GetState();
- }
- }
-
- public int LoopCount
- {
- set
- {
- SetLoopCount(value);
- }
- get
- {
- int ret = GetLoopCount();
- return ret;
- }
- }
-
- public bool Looping
- {
- set
- {
- SetLooping(value);
- }
- get
- {
- bool ret = IsLooping();
- return ret;
- }
- }
-
- public Animation.EndActions EndAction
- {
- set
- {
- SetEndAction(value);
- }
- get
- {
- return GetEndAction();
- }
- }
-
- public void Stop(Animation.EndActions action)
- {
- SetEndAction(action);
- NDalicPINVOKE.Animation_Stop(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public int StartTime { set; get; }
- public int EndTime { set; get; }
- public string TargetProperty { set; get; }
- public object Destination { set; get; }
- public Dali.AlphaFunction AlphaFunction { set; get; }
+ public event EventHandler Finished
+ {
+ add
+ {
+ lock (this)
+ {
+ _animationFinishedEventHandler += value;
+ _animationFinishedEventCallbackDelegate = OnFinished;
+ this.FinishedSignal().Connect(_animationFinishedEventCallbackDelegate);
+ }
+ }
+ remove
+ {
+ lock (this)
+ {
+ if (_animationFinishedEventHandler != null)
+ {
+ this.FinishedSignal().Disconnect(_animationFinishedEventCallbackDelegate);
+ }
+ _animationFinishedEventHandler -= value;
+ }
+ }
+ }
+ // Callback for Animation FinishedSignal
+ private void OnFinished(IntPtr data)
+ {
+ if (_animationFinishedEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _animationFinishedEventHandler(this, null);
+ }
+ }
- public void AnimateBy(Actor target)
- {
- string _str1 = TargetProperty.Substring(0, 1);
- string _str2 = TargetProperty.Substring(1);
- string _str = _str1.ToLower() + _str2;
+ public static Animation GetAnimationFromPtr(global::System.IntPtr cPtr)
+ {
+ Animation ret = new Animation(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- dynamic obj = (object)Destination;
+ private float MilliSecondsToSeconds(int millisec)
+ {
+ return (float)millisec / 1000.0f;
+ }
- if( this.AlphaFunction != null )
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
- }
- }
- else
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateBy(new Property(target, _str), new Property.Value(obj) );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateBy(new Property(target, _str), new Property.Value(obj), time );
- }
- }
- }
+ private int SecondsToMilliSeconds(float sec)
+ {
+ return (int)(sec * 1000);
+ }
- public void AnimateBy(Actor target, string propertyIndex)
- {
- string _str1 = propertyIndex.Substring(0, 1);
- string _str2 = propertyIndex.Substring(1);
- string _str = _str1.ToLower() + _str2;
+ public int Duration
+ {
+ set
+ {
+ SetDuration(MilliSecondsToSeconds(value));
+ }
+ get
+ {
+ return SecondsToMilliSeconds(GetDuration());
+ }
+ }
- dynamic obj = (object)Destination;
+ public AlphaFunction DefaultAlphaFunction
+ {
+ set
+ {
+ SetDefaultAlphaFunction(value);
+ }
+ get
+ {
+ AlphaFunction ret = GetDefaultAlphaFunction();
+ return ret;
+ }
+ }
- if( this.AlphaFunction != null )
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
- }
- }
- else
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateBy(new Property(target, _str), new Property.Value(obj) );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateBy(new Property(target, _str), new Property.Value(obj), time );
- }
- }
- }
+ public Animation.State Status
+ {
+ get
+ {
+ return GetState();
+ }
+ }
- public void AnimateBy(Actor target, string propertyIndex, object relativeValue)
- {
- string _str1 = propertyIndex.Substring(0, 1);
- string _str2 = propertyIndex.Substring(1);
- string _str = _str1.ToLower() + _str2;
+ public int LoopCount
+ {
+ set
+ {
+ SetLoopCount(value);
+ }
+ get
+ {
+ int ret = GetLoopCount();
+ return ret;
+ }
+ }
- dynamic obj = (object)relativeValue;
+ public bool Looping
+ {
+ set
+ {
+ SetLooping(value);
+ }
+ get
+ {
+ bool ret = IsLooping();
+ return ret;
+ }
+ }
- if( this.AlphaFunction != null )
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
- }
- }
- else
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateBy(new Property(target, _str), new Property.Value(obj) );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateBy(new Property(target, _str), new Property.Value(obj), time );
- }
- }
- }
+ public Animation.EndActions EndAction
+ {
+ set
+ {
+ SetEndAction(value);
+ }
+ get
+ {
+ return GetEndAction();
+ }
+ }
- public void AnimateTo(Actor target)
- {
- string _str1 = TargetProperty.Substring(0, 1);
- string _str2 = TargetProperty.Substring(1);
- string _str = _str1.ToLower() + _str2;
+ public void Stop(Animation.EndActions action)
+ {
+ SetEndAction(action);
+ NDalicPINVOKE.Animation_Stop(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- dynamic obj = (object)Destination;
+ public int StartTime { set; get; }
- if( this.AlphaFunction != null )
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
- }
- }
- else
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateTo(new Property(target, _str), new Property.Value(obj) );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateTo(new Property(target, _str), new Property.Value(obj), time );
- }
- }
- }
+ public int EndTime { set; get; }
- public void AnimateTo(Actor target, string propertyIndex)
- {
- string _str1 = propertyIndex.Substring(0, 1);
- string _str2 = propertyIndex.Substring(1);
- string _str = _str1.ToLower() + _str2;
+ public string TargetProperty { set; get; }
- dynamic obj = (object)Destination;
+ public object Destination { set; get; }
- if( this.AlphaFunction != null )
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
- }
- }
- else
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateTo(new Property(target, _str), new Property.Value(obj) );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateTo(new Property(target, _str), new Property.Value(obj), time );
- }
- }
- }
+ public Dali.AlphaFunction AlphaFunction { set; get; }
- public void AnimateTo(Actor target, string propertyIndex, object destinationValue)
- {
- string _str1 = propertyIndex.Substring(0, 1);
- string _str2 = propertyIndex.Substring(1);
- string _str = _str1.ToLower() + _str2;
- dynamic obj = (object)destinationValue;
+ public void AnimateBy(View target)
+ {
+ string _str1 = TargetProperty.Substring(0, 1);
+ string _str2 = TargetProperty.Substring(1);
+ string _str = _str1.ToLower() + _str2;
+
+ dynamic obj = (object)Destination;
+
+ if (this.AlphaFunction != null)
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction);
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time);
+ }
+ }
+ else
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateBy(new Property(target, _str), new Property.Value(obj));
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateBy(new Property(target, _str), new Property.Value(obj), time);
+ }
+ }
+ }
- if( this.AlphaFunction != null )
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
- }
- }
- else
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateTo(new Property(target, _str), new Property.Value(obj) );
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateTo(new Property(target, _str), new Property.Value(obj), time );
- }
- }
- }
+ public void AnimateBy(View target, string propertyIndex)
+ {
+ string _str1 = propertyIndex.Substring(0, 1);
+ string _str2 = propertyIndex.Substring(1);
+ string _str = _str1.ToLower() + _str2;
+
+ dynamic obj = (object)Destination;
+
+ if (this.AlphaFunction != null)
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction);
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time);
+ }
+ }
+ else
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateBy(new Property(target, _str), new Property.Value(obj));
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateBy(new Property(target, _str), new Property.Value(obj), time);
+ }
+ }
+ }
- public void AnimateBetween(Actor target, KeyFrames keyFrames)
- {
- string _str1 = TargetProperty.Substring(0, 1);
- string _str2 = TargetProperty.Substring(1);
- string _str = _str1.ToLower() + _str2;
+ public void AnimateBy(View target, string propertyIndex, object relativeValue)
+ {
+ string _str1 = propertyIndex.Substring(0, 1);
+ string _str2 = propertyIndex.Substring(1);
+ string _str = _str1.ToLower() + _str2;
+
+ dynamic obj = (object)relativeValue;
+
+ if (this.AlphaFunction != null)
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction);
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time);
+ }
+ }
+ else
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateBy(new Property(target, _str), new Property.Value(obj));
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateBy(new Property(target, _str), new Property.Value(obj), time);
+ }
+ }
+ }
+ public void AnimateTo(View target)
+ {
+ string _str1 = TargetProperty.Substring(0, 1);
+ string _str2 = TargetProperty.Substring(1);
+ string _str = _str1.ToLower() + _str2;
+
+ dynamic obj = (object)Destination;
+
+ if (this.AlphaFunction != null)
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction);
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time);
+ }
+ }
+ else
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateTo(new Property(target, _str), new Property.Value(obj));
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateTo(new Property(target, _str), new Property.Value(obj), time);
+ }
+ }
+ }
- if( this.AlphaFunction != null )
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction);
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction, time);
- }
- }
- else
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateBetween(new Property(target, _str), keyFrames);
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateBetween(new Property(target, _str), keyFrames, time);
- }
- }
- }
+ public void AnimateTo(View target, string propertyIndex)
+ {
+ string _str1 = propertyIndex.Substring(0, 1);
+ string _str2 = propertyIndex.Substring(1);
+ string _str = _str1.ToLower() + _str2;
+
+ dynamic obj = (object)Destination;
+
+ if (this.AlphaFunction != null)
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction);
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time);
+ }
+ }
+ else
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateTo(new Property(target, _str), new Property.Value(obj));
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateTo(new Property(target, _str), new Property.Value(obj), time);
+ }
+ }
+ }
- public void AnimateBetween(Actor target, KeyFrames keyFrames, Animation.Interpolation interpolation)
- {
- string _str1 = TargetProperty.Substring(0, 1);
- string _str2 = TargetProperty.Substring(1);
- string _str = _str1.ToLower() + _str2;
+ public void AnimateTo(View target, string propertyIndex, object destinationValue)
+ {
+ string _str1 = propertyIndex.Substring(0, 1);
+ string _str2 = propertyIndex.Substring(1);
+ string _str = _str1.ToLower() + _str2;
+
+ dynamic obj = (object)destinationValue;
+
+ if (this.AlphaFunction != null)
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction);
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time);
+ }
+ }
+ else
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateTo(new Property(target, _str), new Property.Value(obj));
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateTo(new Property(target, _str), new Property.Value(obj), time);
+ }
+ }
+ }
+ public void AnimateBetween(View target, KeyFrames keyFrames)
+ {
+ string _str1 = TargetProperty.Substring(0, 1);
+ string _str2 = TargetProperty.Substring(1);
+ string _str = _str1.ToLower() + _str2;
+
+
+ if (this.AlphaFunction != null)
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction);
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction, time);
+ }
+ }
+ else
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateBetween(new Property(target, _str), keyFrames);
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateBetween(new Property(target, _str), keyFrames, time);
+ }
+ }
+ }
- if( this.AlphaFunction != null )
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction, interpolation);
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction, time, interpolation);
- }
- }
- else
- {
- if( this.StartTime == 0 && this.EndTime == 0 )
- {
- AnimateBetween(new Property(target, _str), keyFrames, interpolation);
- }
- else
- {
- Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
- AnimateBetween(new Property(target, _str), keyFrames, time, interpolation);
- }
- }
- }
+ public void AnimateBetween(View target, KeyFrames keyFrames, Animation.Interpolation interpolation)
+ {
+ string _str1 = TargetProperty.Substring(0, 1);
+ string _str2 = TargetProperty.Substring(1);
+ string _str = _str1.ToLower() + _str2;
+
+
+ if (this.AlphaFunction != null)
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction, interpolation);
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction, time, interpolation);
+ }
+ }
+ else
+ {
+ if (this.StartTime == 0 && this.EndTime == 0)
+ {
+ AnimateBetween(new Property(target, _str), keyFrames, interpolation);
+ }
+ else
+ {
+ Dali.TimePeriod time = new Dali.TimePeriod(MilliSecondsToSeconds(this.StartTime), MilliSecondsToSeconds(this.EndTime - this.StartTime));
+ AnimateBetween(new Property(target, _str), keyFrames, time, interpolation);
+ }
+ }
+ }
- /**
+ /**
* @brief Create an initialized Animation.
*
* The animation will not loop.
* @return A handle to a newly allocated Dali resource.
* @pre DurationmSeconds must be greater than zero.
*/
- public Animation (int durationmSeconds) : this (NDalicPINVOKE.Animation_New((float)durationmSeconds/1000.0f), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Animation () : this (NDalicPINVOKE.Animation_New( 0.0f ), true ) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
-
- public Animation (float durationSeconds) : this (NDalicPINVOKE.Animation_New(durationSeconds), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-
- }
- public static Animation DownCast(BaseHandle handle) {
- Animation ret = new Animation(NDalicPINVOKE.Animation_DownCast(BaseHandle.getCPtr(handle)), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Animation(Animation handle) : this(NDalicPINVOKE.new_Animation__SWIG_1(Animation.getCPtr(handle)), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Animation Assign(Animation rhs) {
- Animation ret = new Animation(NDalicPINVOKE.Animation_Assign(swigCPtr, Animation.getCPtr(rhs)), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetDuration(float seconds) {
- NDalicPINVOKE.Animation_SetDuration(swigCPtr, seconds);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public float GetDuration() {
- float ret = NDalicPINVOKE.Animation_GetDuration(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetLooping(bool looping) {
- NDalicPINVOKE.Animation_SetLooping(swigCPtr, looping);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetLoopCount(int count) {
- NDalicPINVOKE.Animation_SetLoopCount(swigCPtr, count);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public int GetLoopCount() {
- int ret = NDalicPINVOKE.Animation_GetLoopCount(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public int GetCurrentLoop() {
- int ret = NDalicPINVOKE.Animation_GetCurrentLoop(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public bool IsLooping() {
- bool ret = NDalicPINVOKE.Animation_IsLooping(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetEndAction(Animation.EndActions action) {
- NDalicPINVOKE.Animation_SetEndAction(swigCPtr, (int)action);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Animation.EndActions GetEndAction() {
- Animation.EndActions ret = (Animation.EndActions)NDalicPINVOKE.Animation_GetEndAction(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetDisconnectAction(Animation.EndActions disconnectAction) {
- NDalicPINVOKE.Animation_SetDisconnectAction(swigCPtr, (int)disconnectAction);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Animation.EndActions GetDisconnectAction() {
- Animation.EndActions ret = (Animation.EndActions)NDalicPINVOKE.Animation_GetDisconnectAction(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetDefaultAlphaFunction(AlphaFunction alpha) {
- NDalicPINVOKE.Animation_SetDefaultAlphaFunction(swigCPtr, AlphaFunction.getCPtr(alpha));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public AlphaFunction GetDefaultAlphaFunction() {
- AlphaFunction ret = new AlphaFunction(NDalicPINVOKE.Animation_GetDefaultAlphaFunction(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetCurrentProgress(float progress) {
- NDalicPINVOKE.Animation_SetCurrentProgress(swigCPtr, progress);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public float GetCurrentProgress() {
- float ret = NDalicPINVOKE.Animation_GetCurrentProgress(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetSpeedFactor(float factor) {
- NDalicPINVOKE.Animation_SetSpeedFactor(swigCPtr, factor);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public float GetSpeedFactor() {
- float ret = NDalicPINVOKE.Animation_GetSpeedFactor(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetPlayRange(Vector2 range) {
- NDalicPINVOKE.Animation_SetPlayRange(swigCPtr, Vector2.getCPtr(range));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector2 GetPlayRange() {
- Vector2 ret = new Vector2(NDalicPINVOKE.Animation_GetPlayRange(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void Play() {
- NDalicPINVOKE.Animation_Play(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void PlayFrom(float progress) {
- NDalicPINVOKE.Animation_PlayFrom(swigCPtr, progress);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Pause() {
- NDalicPINVOKE.Animation_Pause(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Animation.State GetState() {
- Animation.State ret = (Animation.State)NDalicPINVOKE.Animation_GetState(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void Stop() {
- NDalicPINVOKE.Animation_Stop(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Clear() {
- NDalicPINVOKE.Animation_Clear(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public AnimationSignal FinishedSignal() {
- AnimationSignal ret = new AnimationSignal(NDalicPINVOKE.Animation_FinishedSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void AnimateBy(Property target, Property.Value relativeValue) {
- NDalicPINVOKE.Animation_AnimateBy__SWIG_0(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(relativeValue));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateBy(Property target, Property.Value relativeValue, AlphaFunction alpha) {
- NDalicPINVOKE.Animation_AnimateBy__SWIG_1(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(relativeValue), AlphaFunction.getCPtr(alpha));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateBy(Property target, Property.Value relativeValue, TimePeriod period) {
- NDalicPINVOKE.Animation_AnimateBy__SWIG_2(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(relativeValue), TimePeriod.getCPtr(period));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateBy(Property target, Property.Value relativeValue, AlphaFunction alpha, TimePeriod period) {
- NDalicPINVOKE.Animation_AnimateBy__SWIG_3(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(relativeValue), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateTo(Property target, Property.Value destinationValue) {
- NDalicPINVOKE.Animation_AnimateTo__SWIG_0(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(destinationValue));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateTo(Property target, Property.Value destinationValue, AlphaFunction alpha) {
- NDalicPINVOKE.Animation_AnimateTo__SWIG_1(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(destinationValue), AlphaFunction.getCPtr(alpha));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateTo(Property target, Property.Value destinationValue, TimePeriod period) {
- NDalicPINVOKE.Animation_AnimateTo__SWIG_2(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(destinationValue), TimePeriod.getCPtr(period));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateTo(Property target, Property.Value destinationValue, AlphaFunction alpha, TimePeriod period) {
- NDalicPINVOKE.Animation_AnimateTo__SWIG_3(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(destinationValue), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateBetween(Property target, KeyFrames keyFrames) {
- NDalicPINVOKE.Animation_AnimateBetween__SWIG_0(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateBetween(Property target, KeyFrames keyFrames, Animation.Interpolation interpolation) {
- NDalicPINVOKE.Animation_AnimateBetween__SWIG_1(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), (int)interpolation);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha) {
- NDalicPINVOKE.Animation_AnimateBetween__SWIG_2(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, Animation.Interpolation interpolation) {
- NDalicPINVOKE.Animation_AnimateBetween__SWIG_3(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), (int)interpolation);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateBetween(Property target, KeyFrames keyFrames, TimePeriod period) {
- NDalicPINVOKE.Animation_AnimateBetween__SWIG_4(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), TimePeriod.getCPtr(period));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateBetween(Property target, KeyFrames keyFrames, TimePeriod period, Animation.Interpolation interpolation) {
- NDalicPINVOKE.Animation_AnimateBetween__SWIG_5(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), TimePeriod.getCPtr(period), (int)interpolation);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period) {
- NDalicPINVOKE.Animation_AnimateBetween__SWIG_6(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period, Animation.Interpolation interpolation) {
- NDalicPINVOKE.Animation_AnimateBetween__SWIG_7(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period), (int)interpolation);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Animate(Actor actor, Path path, Vector3 forward) {
- NDalicPINVOKE.Animation_Animate__SWIG_0(swigCPtr, Actor.getCPtr(actor), Path.getCPtr(path), Vector3.getCPtr(forward));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Animate(Actor actor, Path path, Vector3 forward, AlphaFunction alpha) {
- NDalicPINVOKE.Animation_Animate__SWIG_1(swigCPtr, Actor.getCPtr(actor), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Animate(Actor actor, Path path, Vector3 forward, TimePeriod period) {
- NDalicPINVOKE.Animation_Animate__SWIG_2(swigCPtr, Actor.getCPtr(actor), Path.getCPtr(path), Vector3.getCPtr(forward), TimePeriod.getCPtr(period));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Animate(Actor actor, Path path, Vector3 forward, AlphaFunction alpha, TimePeriod period) {
- NDalicPINVOKE.Animation_Animate__SWIG_3(swigCPtr, Actor.getCPtr(actor), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Show(Actor actor, float delaySeconds) {
- NDalicPINVOKE.Animation_Show(swigCPtr, Actor.getCPtr(actor), delaySeconds);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Hide(Actor actor, float delaySeconds) {
- NDalicPINVOKE.Animation_Hide(swigCPtr, Actor.getCPtr(actor), delaySeconds);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public enum EndActions {
- Cancel,
- Discard,
- StopFinal
- }
-
- public enum Interpolation {
- Linear,
- Cubic
- }
-
- public enum State {
- Stopped,
- Playing,
- Paused
- }
+ public Animation(int durationmSeconds) : this(NDalicPINVOKE.Animation_New((float)durationmSeconds / 1000.0f), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
-}
+ public Animation() : this(NDalicPINVOKE.Animation_New(0.0f), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+
+ public Animation(float durationSeconds) : this(NDalicPINVOKE.Animation_New(durationSeconds), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+
+ }
+
+ public static Animation DownCast(BaseHandle handle)
+ {
+ Animation ret = new Animation(NDalicPINVOKE.Animation_DownCast(BaseHandle.getCPtr(handle)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Animation(Animation handle) : this(NDalicPINVOKE.new_Animation__SWIG_1(Animation.getCPtr(handle)), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Animation Assign(Animation rhs)
+ {
+ Animation ret = new Animation(NDalicPINVOKE.Animation_Assign(swigCPtr, Animation.getCPtr(rhs)), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetDuration(float seconds)
+ {
+ NDalicPINVOKE.Animation_SetDuration(swigCPtr, seconds);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public float GetDuration()
+ {
+ float ret = NDalicPINVOKE.Animation_GetDuration(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetLooping(bool looping)
+ {
+ NDalicPINVOKE.Animation_SetLooping(swigCPtr, looping);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetLoopCount(int count)
+ {
+ NDalicPINVOKE.Animation_SetLoopCount(swigCPtr, count);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public int GetLoopCount()
+ {
+ int ret = NDalicPINVOKE.Animation_GetLoopCount(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public int GetCurrentLoop()
+ {
+ int ret = NDalicPINVOKE.Animation_GetCurrentLoop(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public bool IsLooping()
+ {
+ bool ret = NDalicPINVOKE.Animation_IsLooping(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetEndAction(Animation.EndActions action)
+ {
+ NDalicPINVOKE.Animation_SetEndAction(swigCPtr, (int)action);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Animation.EndActions GetEndAction()
+ {
+ Animation.EndActions ret = (Animation.EndActions)NDalicPINVOKE.Animation_GetEndAction(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetDisconnectAction(Animation.EndActions disconnectAction)
+ {
+ NDalicPINVOKE.Animation_SetDisconnectAction(swigCPtr, (int)disconnectAction);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Animation.EndActions GetDisconnectAction()
+ {
+ Animation.EndActions ret = (Animation.EndActions)NDalicPINVOKE.Animation_GetDisconnectAction(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetDefaultAlphaFunction(AlphaFunction alpha)
+ {
+ NDalicPINVOKE.Animation_SetDefaultAlphaFunction(swigCPtr, AlphaFunction.getCPtr(alpha));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public AlphaFunction GetDefaultAlphaFunction()
+ {
+ AlphaFunction ret = new AlphaFunction(NDalicPINVOKE.Animation_GetDefaultAlphaFunction(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetCurrentProgress(float progress)
+ {
+ NDalicPINVOKE.Animation_SetCurrentProgress(swigCPtr, progress);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public float GetCurrentProgress()
+ {
+ float ret = NDalicPINVOKE.Animation_GetCurrentProgress(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetSpeedFactor(float factor)
+ {
+ NDalicPINVOKE.Animation_SetSpeedFactor(swigCPtr, factor);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public float GetSpeedFactor()
+ {
+ float ret = NDalicPINVOKE.Animation_GetSpeedFactor(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetPlayRange(Vector2 range)
+ {
+ NDalicPINVOKE.Animation_SetPlayRange(swigCPtr, Vector2.getCPtr(range));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Vector2 GetPlayRange()
+ {
+ Vector2 ret = new Vector2(NDalicPINVOKE.Animation_GetPlayRange(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void Play()
+ {
+ NDalicPINVOKE.Animation_Play(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void PlayFrom(float progress)
+ {
+ NDalicPINVOKE.Animation_PlayFrom(swigCPtr, progress);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Pause()
+ {
+ NDalicPINVOKE.Animation_Pause(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Animation.State GetState()
+ {
+ Animation.State ret = (Animation.State)NDalicPINVOKE.Animation_GetState(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void Stop()
+ {
+ NDalicPINVOKE.Animation_Stop(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Clear()
+ {
+ NDalicPINVOKE.Animation_Clear(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public AnimationSignal FinishedSignal()
+ {
+ AnimationSignal ret = new AnimationSignal(NDalicPINVOKE.Animation_FinishedSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void AnimateBy(Property target, Property.Value relativeValue)
+ {
+ NDalicPINVOKE.Animation_AnimateBy__SWIG_0(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(relativeValue));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateBy(Property target, Property.Value relativeValue, AlphaFunction alpha)
+ {
+ NDalicPINVOKE.Animation_AnimateBy__SWIG_1(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(relativeValue), AlphaFunction.getCPtr(alpha));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateBy(Property target, Property.Value relativeValue, TimePeriod period)
+ {
+ NDalicPINVOKE.Animation_AnimateBy__SWIG_2(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(relativeValue), TimePeriod.getCPtr(period));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateBy(Property target, Property.Value relativeValue, AlphaFunction alpha, TimePeriod period)
+ {
+ NDalicPINVOKE.Animation_AnimateBy__SWIG_3(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(relativeValue), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateTo(Property target, Property.Value destinationValue)
+ {
+ NDalicPINVOKE.Animation_AnimateTo__SWIG_0(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(destinationValue));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateTo(Property target, Property.Value destinationValue, AlphaFunction alpha)
+ {
+ NDalicPINVOKE.Animation_AnimateTo__SWIG_1(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(destinationValue), AlphaFunction.getCPtr(alpha));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateTo(Property target, Property.Value destinationValue, TimePeriod period)
+ {
+ NDalicPINVOKE.Animation_AnimateTo__SWIG_2(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(destinationValue), TimePeriod.getCPtr(period));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateTo(Property target, Property.Value destinationValue, AlphaFunction alpha, TimePeriod period)
+ {
+ NDalicPINVOKE.Animation_AnimateTo__SWIG_3(swigCPtr, Property.getCPtr(target), Property.Value.getCPtr(destinationValue), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateBetween(Property target, KeyFrames keyFrames)
+ {
+ NDalicPINVOKE.Animation_AnimateBetween__SWIG_0(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateBetween(Property target, KeyFrames keyFrames, Animation.Interpolation interpolation)
+ {
+ NDalicPINVOKE.Animation_AnimateBetween__SWIG_1(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), (int)interpolation);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha)
+ {
+ NDalicPINVOKE.Animation_AnimateBetween__SWIG_2(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, Animation.Interpolation interpolation)
+ {
+ NDalicPINVOKE.Animation_AnimateBetween__SWIG_3(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), (int)interpolation);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateBetween(Property target, KeyFrames keyFrames, TimePeriod period)
+ {
+ NDalicPINVOKE.Animation_AnimateBetween__SWIG_4(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), TimePeriod.getCPtr(period));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateBetween(Property target, KeyFrames keyFrames, TimePeriod period, Animation.Interpolation interpolation)
+ {
+ NDalicPINVOKE.Animation_AnimateBetween__SWIG_5(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), TimePeriod.getCPtr(period), (int)interpolation);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period)
+ {
+ NDalicPINVOKE.Animation_AnimateBetween__SWIG_6(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period, Animation.Interpolation interpolation)
+ {
+ NDalicPINVOKE.Animation_AnimateBetween__SWIG_7(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period), (int)interpolation);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Animate(View view, Path path, Vector3 forward)
+ {
+ NDalicPINVOKE.Animation_Animate__SWIG_0(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Animate(View view, Path path, Vector3 forward, AlphaFunction alpha)
+ {
+ NDalicPINVOKE.Animation_Animate__SWIG_1(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Animate(View view, Path path, Vector3 forward, TimePeriod period)
+ {
+ NDalicPINVOKE.Animation_Animate__SWIG_2(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), TimePeriod.getCPtr(period));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Animate(View view, Path path, Vector3 forward, AlphaFunction alpha, TimePeriod period)
+ {
+ NDalicPINVOKE.Animation_Animate__SWIG_3(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Show(View view, float delaySeconds)
+ {
+ NDalicPINVOKE.Animation_Show(swigCPtr, View.getCPtr(view), delaySeconds);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Hide(View view, float delaySeconds)
+ {
+ NDalicPINVOKE.Animation_Hide(swigCPtr, View.getCPtr(view), delaySeconds);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public enum EndActions
+ {
+ Cancel,
+ Discard,
+ StopFinal
+ }
+
+ public enum Interpolation
+ {
+ Linear,
+ Cubic
+ }
+
+ public enum State
+ {
+ Stopped,
+ Playing,
+ Paused
+ }
+
+ }
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public Animation CreateAnimation(string animationName, Actor sourceActor) {
- Animation ret = new Animation(NDalicPINVOKE.Builder_CreateAnimation__SWIG_2(swigCPtr, animationName, Actor.getCPtr(sourceActor)), true);
+ public Animation CreateAnimation(string animationName, View sourceActor) {
+ Animation ret = new Animation(NDalicPINVOKE.Builder_CreateAnimation__SWIG_2(swigCPtr, animationName, View.getCPtr(sourceActor)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Animation CreateAnimation(string animationName, Property.Map map, Actor sourceActor) {
- Animation ret = new Animation(NDalicPINVOKE.Builder_CreateAnimation__SWIG_3(swigCPtr, animationName, Property.Map.getCPtr(map), Actor.getCPtr(sourceActor)), true);
+ public Animation CreateAnimation(string animationName, Property.Map map, View sourceActor) {
+ Animation ret = new Animation(NDalicPINVOKE.Builder_CreateAnimation__SWIG_3(swigCPtr, animationName, Property.Map.getCPtr(map), View.getCPtr(sourceActor)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public bool ApplyStyle(string styleName, Handle handle) {
- bool ret = NDalicPINVOKE.Builder_ApplyStyle(swigCPtr, styleName, Handle.getCPtr(handle));
+ public bool ApplyStyle(string styleName, Animatable handle) {
+ bool ret = NDalicPINVOKE.Builder_ApplyStyle(swigCPtr, styleName, Animatable.getCPtr(handle));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public bool ApplyFromJson(Handle handle, string json) {
- bool ret = NDalicPINVOKE.Builder_ApplyFromJson(swigCPtr, Handle.getCPtr(handle), json);
+ public bool ApplyFromJson(Animatable handle, string json) {
+ bool ret = NDalicPINVOKE.Builder_ApplyFromJson(swigCPtr, Animatable.getCPtr(handle), json);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public void AddActors(Actor toActor) {
- NDalicPINVOKE.Builder_AddActors__SWIG_0(swigCPtr, Actor.getCPtr(toActor));
+ public void AddViews(View toView) {
+ NDalicPINVOKE.Builder_AddActors__SWIG_0(swigCPtr, View.getCPtr(toView));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void AddActors(string sectionName, Actor toActor) {
- NDalicPINVOKE.Builder_AddActors__SWIG_1(swigCPtr, sectionName, Actor.getCPtr(toActor));
+ public void AddViews(string sectionName, View toView) {
+ NDalicPINVOKE.Builder_AddActors__SWIG_1(swigCPtr, sectionName, View.getCPtr(toView));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public void SetLabel(Actor label) {
- NDalicPINVOKE.Button_SetLabel(swigCPtr, Actor.getCPtr(label));
+ public void SetLabel(View label) {
+ NDalicPINVOKE.Button_SetLabel(swigCPtr, View.getCPtr(label));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetButtonImage() {
- Actor ret = new Actor(NDalicPINVOKE.Button_GetButtonImage(swigCPtr), true);
+ public View GetButtonImage() {
+ View ret = new View(NDalicPINVOKE.Button_GetButtonImage(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor GetSelectedImage() {
- Actor ret = new Actor(NDalicPINVOKE.Button_GetSelectedImage(swigCPtr), true);
+ public View GetSelectedImage() {
+ View ret = new View(NDalicPINVOKE.Button_GetSelectedImage(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
namespace Dali {
-public class CameraActor : Actor {
+ public class Camera : Animatable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- internal CameraActor(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.CameraActor_SWIGUpcast(cPtr), cMemoryOwn) {
+ internal Camera(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.CameraActor_SWIGUpcast(cPtr), cMemoryOwn) {
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(CameraActor obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Camera obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~CameraActor() {
+ ~Camera() {
DisposeQueue.Instance.Add(this);
}
- public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
global::System.GC.SuppressFinalize(this);
- base.Dispose();
}
}
}
- public CameraActor () : this (NDalicPINVOKE.CameraActor_New__SWIG_0(), true) {
+ public Camera () : this (NDalicPINVOKE.CameraActor_New__SWIG_0(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public CameraActor (Vector2 size) : this (NDalicPINVOKE.CameraActor_New__SWIG_1(Vector2.getCPtr(size)), true) {
+ public Camera (Vector2 size) : this (NDalicPINVOKE.CameraActor_New__SWIG_1(Vector2.getCPtr(size)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public new static CameraActor DownCast(BaseHandle handle) {
- CameraActor ret = new CameraActor(NDalicPINVOKE.CameraActor_DownCast(BaseHandle.getCPtr(handle)), true);
+ public new static Camera DownCast(BaseHandle handle) {
+ Camera ret = new Camera(NDalicPINVOKE.CameraActor_DownCast(BaseHandle.getCPtr(handle)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public CameraActor(CameraActor copy) : this(NDalicPINVOKE.new_CameraActor__SWIG_1(CameraActor.getCPtr(copy)), true) {
+ public Camera(Camera copy) : this(NDalicPINVOKE.new_CameraActor__SWIG_1(Camera.getCPtr(copy)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public CameraActor Assign(CameraActor rhs) {
- CameraActor ret = new CameraActor(NDalicPINVOKE.CameraActor_Assign(swigCPtr, CameraActor.getCPtr(rhs)), false);
+ public Camera Assign(Camera rhs) {
+ Camera ret = new Camera(NDalicPINVOKE.CameraActor_Assign(swigCPtr, Camera.getCPtr(rhs)), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
get
{
string temp;
- GetProperty( CameraActor.Property.TYPE).Get( out temp );
+ GetProperty( Camera.Property.TYPE).Get( out temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.TYPE, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.TYPE, new Dali.Property.Value( value ) );
}
}
public string ProjectionMode
get
{
string temp;
- GetProperty( CameraActor.Property.PROJECTION_MODE).Get( out temp );
+ GetProperty( Camera.Property.PROJECTION_MODE).Get( out temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.PROJECTION_MODE, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.PROJECTION_MODE, new Dali.Property.Value( value ) );
}
}
public float FieldOfView
get
{
float temp = 0.0f;
- GetProperty( CameraActor.Property.FIELD_OF_VIEW).Get( ref temp );
+ GetProperty( Camera.Property.FIELD_OF_VIEW).Get( ref temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.FIELD_OF_VIEW, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.FIELD_OF_VIEW, new Dali.Property.Value( value ) );
}
}
public float AspectRatio
get
{
float temp = 0.0f;
- GetProperty( CameraActor.Property.ASPECT_RATIO).Get( ref temp );
+ GetProperty( Camera.Property.ASPECT_RATIO).Get( ref temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.ASPECT_RATIO, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.ASPECT_RATIO, new Dali.Property.Value( value ) );
}
}
public float NearPlaneDistance
get
{
float temp = 0.0f;
- GetProperty( CameraActor.Property.NEAR_PLANE_DISTANCE).Get( ref temp );
+ GetProperty( Camera.Property.NEAR_PLANE_DISTANCE).Get( ref temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.NEAR_PLANE_DISTANCE, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.NEAR_PLANE_DISTANCE, new Dali.Property.Value( value ) );
}
}
public float FarPlaneDistance
get
{
float temp = 0.0f;
- GetProperty( CameraActor.Property.FAR_PLANE_DISTANCE).Get( ref temp );
+ GetProperty( Camera.Property.FAR_PLANE_DISTANCE).Get( ref temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.FAR_PLANE_DISTANCE, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.FAR_PLANE_DISTANCE, new Dali.Property.Value( value ) );
}
}
public float LeftPlaneDistance
get
{
float temp = 0.0f;
- GetProperty( CameraActor.Property.LEFT_PLANE_DISTANCE).Get( ref temp );
+ GetProperty( Camera.Property.LEFT_PLANE_DISTANCE).Get( ref temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.LEFT_PLANE_DISTANCE, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.LEFT_PLANE_DISTANCE, new Dali.Property.Value( value ) );
}
}
public float RightPlaneDistance
get
{
float temp = 0.0f;
- GetProperty( CameraActor.Property.RIGHT_PLANE_DISTANCE).Get( ref temp );
+ GetProperty( Camera.Property.RIGHT_PLANE_DISTANCE).Get( ref temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.RIGHT_PLANE_DISTANCE, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.RIGHT_PLANE_DISTANCE, new Dali.Property.Value( value ) );
}
}
public float TopPlaneDistance
get
{
float temp = 0.0f;
- GetProperty( CameraActor.Property.TOP_PLANE_DISTANCE).Get( ref temp );
+ GetProperty( Camera.Property.TOP_PLANE_DISTANCE).Get( ref temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.TOP_PLANE_DISTANCE, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.TOP_PLANE_DISTANCE, new Dali.Property.Value( value ) );
}
}
public float BottomPlaneDistance
get
{
float temp = 0.0f;
- GetProperty( CameraActor.Property.BOTTOM_PLANE_DISTANCE).Get( ref temp );
+ GetProperty( Camera.Property.BOTTOM_PLANE_DISTANCE).Get( ref temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.BOTTOM_PLANE_DISTANCE, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.BOTTOM_PLANE_DISTANCE, new Dali.Property.Value( value ) );
}
}
public Vector3 TargetPosition
get
{
Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
- GetProperty( CameraActor.Property.TARGET_POSITION).Get( temp );
+ GetProperty( Camera.Property.TARGET_POSITION).Get( temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.TARGET_POSITION, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.TARGET_POSITION, new Dali.Property.Value( value ) );
}
}
public Matrix ProjectionMatrix
get
{
Matrix temp = new Matrix();
- GetProperty( CameraActor.Property.PROJECTION_MATRIX).Get( temp );
+ GetProperty( Camera.Property.PROJECTION_MATRIX).Get( temp );
return temp;
}
} public Matrix ViewMatrix
get
{
Matrix temp = new Matrix();
- GetProperty( CameraActor.Property.VIEW_MATRIX).Get( temp );
+ GetProperty( Camera.Property.VIEW_MATRIX).Get( temp );
return temp;
}
} public bool InvertYAxis
get
{
bool temp = false;
- GetProperty( CameraActor.Property.INVERT_Y_AXIS).Get( ref temp );
+ GetProperty( Camera.Property.INVERT_Y_AXIS).Get( ref temp );
return temp;
}
set
{
- SetProperty( CameraActor.Property.INVERT_Y_AXIS, new Dali.Property.Value( value ) );
+ SetProperty( Camera.Property.INVERT_Y_AXIS, new Dali.Property.Value( value ) );
}
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
namespace Dali {
-public class CustomActor : Actor {
+ public class CustomActor : Animatable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal CustomActor(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.CustomActor_SWIGUpcast(cPtr), cMemoryOwn) {
DisposeQueue.Instance.Add(this);
}
- public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
global::System.GC.SuppressFinalize(this);
- base.Dispose();
}
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public virtual void OnChildAdd(Actor child) {
- NDalicPINVOKE.CustomActorImpl_OnChildAdd(swigCPtr, Actor.getCPtr(child));
+ public virtual void OnChildAdd(View child) {
+ NDalicPINVOKE.CustomActorImpl_OnChildAdd(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public virtual void OnChildRemove(Actor child) {
- NDalicPINVOKE.CustomActorImpl_OnChildRemove(swigCPtr, Actor.getCPtr(child));
+ public virtual void OnChildRemove(View child) {
+ NDalicPINVOKE.CustomActorImpl_OnChildRemove(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
return ret;
}
- public virtual float CalculateChildSize(Actor child, DimensionType dimension) {
- float ret = NDalicPINVOKE.CustomActorImpl_CalculateChildSize(swigCPtr, Actor.getCPtr(child), (int)dimension);
+ public virtual float CalculateChildSize(View child, DimensionType dimension) {
+ float ret = NDalicPINVOKE.CustomActorImpl_CalculateChildSize(swigCPtr, View.getCPtr(child), (int)dimension);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
- public virtual Actor GetNextFocusableActor(Actor current, Actor proposed, View.KeyboardFocus.Direction direction) {
- Actor ret = new Actor(NDalicPINVOKE.CustomAlgorithmInterface_GetNextFocusableActor(swigCPtr, Actor.getCPtr(current), Actor.getCPtr(proposed), (int)direction), true);
+ public virtual View GetNextFocusableView(View current, View proposed, View.KeyboardFocus.Direction direction) {
+ View ret = new View(NDalicPINVOKE.CustomAlgorithmInterface_GetNextFocusableActor(swigCPtr, View.getCPtr(current), View.getCPtr(proposed), (int)direction), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
private void SwigDirectorConnect() {
- if (SwigDerivedClassHasMethod("GetNextFocusableActor", swigMethodTypes0))
- swigDelegate0 = new SwigDelegateCustomAlgorithmInterface_0(SwigDirectorGetNextFocusableActor);
+ if (SwigDerivedClassHasMethod("GetNextFocusableView", swigMethodTypes0))
+ swigDelegate0 = new SwigDelegateCustomAlgorithmInterface_0(SwigDirectorGetNextFocusableView);
NDalicPINVOKE.CustomAlgorithmInterface_director_connect(swigCPtr, swigDelegate0);
}
return hasDerivedMethod;
}
- private global::System.IntPtr SwigDirectorGetNextFocusableActor(global::System.IntPtr current, global::System.IntPtr proposed, int direction) {
- return Actor.getCPtr(GetNextFocusableActor(new Actor(current, true), new Actor(proposed, true), (View.KeyboardFocus.Direction)direction)).Handle;
+ private global::System.IntPtr SwigDirectorGetNextFocusableView(global::System.IntPtr current, global::System.IntPtr proposed, int direction) {
+ return View.getCPtr(GetNextFocusableView(new View(current, true), new View(proposed, true), (View.KeyboardFocus.Direction)direction)).Handle;
}
public delegate global::System.IntPtr SwigDelegateCustomAlgorithmInterface_0(global::System.IntPtr current, global::System.IntPtr proposed, int direction);
private SwigDelegateCustomAlgorithmInterface_0 swigDelegate0;
- private static global::System.Type[] swigMethodTypes0 = new global::System.Type[] { typeof(Actor), typeof(Actor), typeof(View.KeyboardFocus.Direction) };
+ private static global::System.Type[] swigMethodTypes0 = new global::System.Type[] { typeof(View), typeof(View), typeof(View.KeyboardFocus.Direction) };
}
}
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.GetNextKeyboardFocusableActor = new ViewWrapperImpl.GetNextKeyboardFocusableActorDelegate(GetNextKeyboardFocusableView);
viewWrapperImpl.OnKeyboardFocusChangeCommitted = new ViewWrapperImpl.OnKeyboardFocusChangeCommittedDelegate(OnKeyboardFocusChangeCommitted);
viewWrapperImpl.OnKeyboardEnter = new ViewWrapperImpl.OnKeyboardEnterDelegate(OnKeyboardEnter);
viewWrapperImpl.OnPinch = new ViewWrapperImpl.OnPinchDelegate(OnPinch);
// Set the StyleName the name of the View
// We have to do this because the StyleManager on Native side can't workout it out
- // This will also ensure that the style of actors/visuals initialized above are applied by the style manager.
+ // This will also ensure that the style of views/visuals initialized above are applied by the style manager.
SetStyleName( this.GetType().Name );
}
/**
* @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).
+ * keyboard focus movement between its child views).
*
* The control doesn't support it by default.
* @param[in] isSupported Whether this control supports two dimensional keyboard navigation.
* @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.
+ * can be limitied to its child views). 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)
}
/**
- * @brief Request a relayout, which means performing a size negotiation on this actor, its parent and children (and potentially whole scene).
+ * @brief Request a relayout, which means performing a size negotiation on this view, 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
}
/**
- * @brief Provides the Actor implementation of GetHeightForWidth.
+ * @brief Provides the View implementation of GetHeightForWidth.
* @param width Width to use.
* @return The height based on the width.
*/
}
/**
- * @brief Provides the Actor implementation of GetWidthForHeight.
+ * @brief Provides the View implementation of GetWidthForHeight.
* @param height Height to use.
* @return The width based on the height.
*/
}
/**
- * @brief Calculate the size for a child using the base actor object.
+ * @brief Calculate the size for a child using the base view object.
*
- * @param[in] child The child actor to calculate the size for
+ * @param[in] child The child view 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)
+ protected float CalculateChildSizeBase(View 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.
+ * @brief Determine if this view 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.
+ * @return Return if the view is dependent on it's children.
*/
protected bool RelayoutDependentOnChildrenBase(DimensionType dimension)
{
}
/**
- * @brief Determine if this actor is dependent on it's children for relayout from the base class.
+ * @brief Determine if this view 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.
+ * @return Return if the view is dependent on it's children.
*/
protected bool 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.
+ * @brief Register a visual by Property Index, linking an View to visual when required.
+ * In the case of the visual being an view 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.
+ * @note Derived class should not call visual.SetOnStage(view). 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)
}
/**
- * @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.
+ * @brief Register a visual by Property Index, linking an View to visual when required.
+ * In the case of the visual being an view 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
*
}
/**
- * @brief Called after the actor has been connected to the stage.
+ * @brief Called after the view 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
+ * When an view is connected, it will be directly or indirectly parented to the root View.
+ * @param[in] depth The depth in the hierarchy for the view
*
- * @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
+ * @note The root View is provided automatically by Dali::Stage, and is always considered to be connected.
+ * When the parent of a set of views 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.
+ * For the following view tree, the callback order will be A, B, D, E, C, and finally F.
*
* @code
*
* D E F
*
* @endcode
- * @param[in] depth The depth in the hierarchy for the actor
+ * @param[in] depth The depth in the hierarchy for the view
*/
public virtual void OnStageConnection(int depth)
{
}
/**
- * @brief Called after the actor has been disconnected from Stage.
+ * @brief Called after the view has been disconnected from Stage.
*
- * If an actor is disconnected it either has no parent, or is parented to a disconnected actor.
+ * If an view is disconnected it either has no parent, or is parented to a disconnected view.
*
- * @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.
+ * @note When the parent of a set of views is disconnected to the stage, then all of the children
+ * will received this callback, starting with the leaf views.
+ * For the following view tree, the callback order will be D, E, B, F, C, and finally A.
*
* @code
*
}
/**
- * @brief Called after a child has been added to the owning actor.
+ * @brief Called after a child has been added to the owning view.
*
* @param[in] child The child which has been added
*/
- public virtual void OnChildAdd(Actor actor)
+ public virtual void OnChildAdd(View view)
{
}
/**
- * @brief Called after the owning actor has attempted to remove a child( regardless of whether it succeeded or not ).
+ * @brief Called after the owning view 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)
+ public virtual void OnChildRemove(View View)
{
}
/**
- * @brief Called when the owning actor property is set.
+ * @brief Called when the owning view property is set.
*
* @param[in] index The Property index that was set
* @param[in] propertyValue The value to set
}
/**
- * @brief Called when the owning actor's size is set e.g. using Actor::SetSize().
+ * @brief Called when the owning view's size is set e.g. using View::SetSize().
*
- * @param[in] targetSize The target size. Note that this target size may not match the size returned via Actor.GetTargetSize.
+ * @param[in] targetSize The target size. Note that this target size may not match the size returned via View.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 ), ... ).
+ * @brief Called when the owning view's size is animated e.g. using Animation::AnimateTo( Property( view, View::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.
+ * @param[in] animation The object which is animating the owning view.
+ * @param[in] targetSize The target size. Note that this target size may not match the size returned via @ref View.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.
+ * @brief Called after a touch-event is received by the owning view.
*
* @param[in] touch The touch event
* @return True if the event should be consumed.
}
/**
- * @brief Called after a hover-event is received by the owning actor.
+ * @brief Called after a hover-event is received by the owning view.
*
* @param[in] hover The hover event
* @return True if the hover event should be consumed.
}
/**
- * @brief Called after a key-event is received by the actor that has had its focus set.
+ * @brief Called after a key-event is received by the view that has had its focus set.
*
* @param[in] key the Key Event
* @return True if the event should be consumed.
}
/**
- * @brief Called after a wheel-event is received by the owning actor.
+ * @brief Called after a wheel-event is received by the owning view.
*
* @param[in] wheel The wheel event
* @return True if the event should be consumed.
* 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.
+ * views differently after certain operations like add or remove
+ * views, 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
+ * @param[in,out] container The control should add views 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).
}
/**
- * @brief Return the natural size of the actor.
+ * @brief Return the natural size of the view.
*
- * @return The actor's natural size
+ * @return The view's natural size
*/
public virtual Vector3 GetNaturalSize()
{
/**
* @brief Calculate the size for a child.
*
- * @param[in] child The child actor to calculate the size for
+ * @param[in] child The child view 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)
+ public virtual float CalculateChildSize(View child, DimensionType dimension)
{
return viewWrapperImpl.CalculateChildSizeBase( child, dimension );
}
}
/**
- * @brief Determine if this actor is dependent on it's children for relayout.
+ * @brief Determine if this view 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.
+ * @return Return if the view is dependent on it's children.
*/
public virtual bool RelayoutDependentOnChildren(DimensionType dimension)
{
}
/**
- * @brief Determine if this actor is dependent on it's children for relayout from the base class.
+ * @brief Determine if this view is dependent on it's children for relayout from the base class.
*
- * @return Return if the actor is dependent on it's children.
+ * @return Return if the view is dependent on it's children.
*/
public virtual bool RelayoutDependentOnChildren()
{
}
/**
- * @brief Gets the next keyboard focusable actor in this control towards the given direction.
+ * @brief Gets the next keyboard focusable view 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] currentFocusedView The current focused view.
* @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.
+ * @param[in] loopEnabled Whether the focus movement should be looped within the view.
+ * @return the next keyboard focusable view in this control or an empty handle if no view can be focused.
*/
- public virtual Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, View.KeyboardFocus.Direction direction, bool loopEnabled)
+ public virtual View GetNextKeyboardFocusableView(View currentFocusedView, View.KeyboardFocus.Direction direction, bool loopEnabled)
{
- return new Actor();
+ return new View();
}
/**
- * @brief Informs this control that its chosen focusable actor will be focused.
+ * @brief Informs this control that its chosen focusable view will be focused.
*
* This allows the application to preform any actions if wishes
- * before the focus is actually moved to the chosen actor.
+ * before the focus is actually moved to the chosen view.
*
- * @param[in] commitedFocusableActor The commited focusable actor.
+ * @param[in] commitedFocusableView The commited focusable view.
*/
- public virtual void OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor)
+ public virtual void OnKeyboardFocusChangeCommitted(View commitedFocusableView)
{
}
{
}
- private void OnControlChildAdd(Actor child)
+ private void OnControlChildAdd(View child)
{
}
- private void OnControlChildRemove(Actor child)
+ private void OnControlChildRemove(View child)
{
}
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
{
private static readonly DisposeQueue _disposableQueue = new DisposeQueue();
private List<IDisposable> _disposables = new List<IDisposable>();
- private Object _listLock = new object();
+ private System.Object _listLock = new object();
private EventThreadCallback _eventThreadCallback;
private EventThreadCallback.CallbackDelegate _disposeQueueProcessDisposablesDelegate;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, Actor arg2) {
- NDalicPINVOKE.FocusChangedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Actor.getCPtr(arg2));
+ public void Emit(View arg1, View arg2) {
+ NDalicPINVOKE.FocusChangedSignal_Emit(swigCPtr, View.getCPtr(arg1), View.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, bool arg2) {
- NDalicPINVOKE.FocusGroupChangedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), arg2);
+ public void Emit(View arg1, bool arg2) {
+ NDalicPINVOKE.FocusGroupChangedSignal_Emit(swigCPtr, View.getCPtr(arg1), arg2);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
*/
public class FocusChangedEventArgs : EventArgs
{
- private Actor _actorCurrent;
- private Actor _actorNext;
+ private View _viewCurrent;
+ private View _viewNext;
/**
- * @brief Actor - is the original focused Actor
+ * @brief ViewCurrent - is the original focused View
*
*/
- public Actor ActorCurrent
+ public View ViewCurrent
{
get
{
- return _actorCurrent;
+ return _viewCurrent;
}
set
{
- _actorCurrent = value;
+ _viewCurrent = value;
}
}
/**
- * @brief Actor - is the current focused Actor
+ * @brief ViewNext - is the current focused View
*
*/
- public Actor ActorNext
+ public View ViewNext
{
get
{
- return _actorNext;
+ return _viewNext;
}
set
{
- _actorNext = value;
+ _viewNext = value;
}
}
}
*/
public class FocusGroupChangedEventArgs : EventArgs
{
- private Actor _currentFocusedActor;
+ private View _currentFocusedView;
private bool _forwardDirection;
/**
- * @brief Actor - is the current focused Actor
+ * @brief CurrentFocusedView - is the current focused View
*
*/
- public Actor CurrentFocusedActor
+ public View CurrentFocusedView
{
get
{
- return _currentFocusedActor;
+ return _currentFocusedView;
}
set
{
- _currentFocusedActor = value;
+ _currentFocusedView = value;
}
}
}
/**
- * @brief Event arguments that passed via FocusedActorEnterKey signal
+ * @brief Event arguments that passed via FocusedViewEnterKey signal
*
*/
-public class FocusedActorEnterKeyEventArgs : EventArgs
+public class FocusedViewEnterKeyEventArgs : EventArgs
{
- private Actor _actor;
+ private View _view;
/**
- * @brief Actor - is the current focused Actor which has the enter key pressed on it.
+ * @brief View - is the current focused View which has the enter key pressed on it.
*
*/
- public Actor Actor
+ public View View
{
get
{
- return _actor;
+ return _view;
}
set
{
- _actor = value;
+ _view = value;
}
}
}
*/
public class PreFocusChangeEventArgs : EventArgs
{
- private Actor _current;
- private Actor _proposed;
+ private View _current;
+ private View _proposed;
private View.KeyboardFocus.Direction _direction;
/**
- * @brief Actor - is the current focused Actor.
+ * @brief Current - is the current focused View.
*
*/
- public Actor Current
+ public View Current
{
get
{
}
/**
- * @brief Actor - is the proposed focused Actor.
+ * @brief Proposed - is the proposed focused View.
*
*/
- public Actor Proposed
+ public View Proposed
{
get
{
public delegate void FocusGroupChangedEventHandler(object source, FocusGroupChangedEventArgs e);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void FocusedActorEnterKeyEventHandler(object source, FocusedActorEnterKeyEventArgs e);
+ public delegate void FocusedViewEnterKeyEventHandler(object source, FocusedViewEnterKeyEventArgs e);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate Actor PreFocusChangeEventHandler(object source, PreFocusChangeEventArgs e);
+ public delegate View PreFocusChangeEventHandler(object source, PreFocusChangeEventArgs e);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
public delegate IntPtr PreFocusChangeEventCallbackDelegate(IntPtr current, IntPtr proposed, View.KeyboardFocus.Direction direction);
private FocusGroupChangedEventCallbackDelegate _FocusManagerFocusGroupChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void FocusedActorEnterKeyEventCallbackDelegate(IntPtr actor);
- private FocusedActorEnterKeyEventHandler _FocusManagerFocusedActorEnterKeyEventHandler;
- private FocusedActorEnterKeyEventCallbackDelegate _FocusManagerFocusedActorEnterKeyEventCallbackDelegate;
+ private delegate void FocusedViewEnterKeyEventCallbackDelegate(IntPtr actor);
+ private FocusedViewEnterKeyEventHandler _FocusManagerFocusedViewEnterKeyEventHandler;
+ private FocusedViewEnterKeyEventCallbackDelegate _FocusManagerFocusedViewEnterKeyEventCallbackDelegate;
public event PreFocusChangeEventHandler PreFocusChange
{
// Callback for FocusManager PreFocusChangeSignal
private IntPtr OnPreFocusChange(IntPtr current, IntPtr proposed, View.KeyboardFocus.Direction direction)
{
- Actor actor = null;
+ View view = null;
PreFocusChangeEventArgs e = new PreFocusChangeEventArgs();
// Populate all members of "e" (PreFocusChangeEventArgs) with real data
- e.Current = Actor.GetActorFromPtr(current);
- e.Proposed = Actor.GetActorFromPtr(proposed);
+ if (current != global::System.IntPtr.Zero)
+ {
+ e.Current = View.GetViewFromPtr(current);
+ }
+
+ if (proposed != global::System.IntPtr.Zero)
+ {
+ e.Proposed = View.GetViewFromPtr(proposed);
+ }
+
e.Direction = direction;
if (_FocusManagerPreFocusChangeEventHandler != null)
{
//here we send all data to user event handlers
- actor = _FocusManagerPreFocusChangeEventHandler(this, e);
+ view = _FocusManagerPreFocusChangeEventHandler(this, e);
}
- return actor.GetPtrfromActor();
+ if (view)
+ {
+ return view.GetPtrfromView();
+ }
+ else
+ {
+ return current;
+ }
}
/**
* @brief Event for FocusChanged signal which can be used to subscribe/unsubscribe the event handler
* (in the type of FocusChangedEventHandler) provided by the user.
- * FocusChanged signal is emitted after the current focused actor has been changed.
+ * FocusChanged signal is emitted after the current focused view has been changed.
*/
public event FocusChangedEventHandler FocusChanged
{
}
// Callback for FocusManager FocusChangedSignal
- private void OnFocusChanged(IntPtr actorCurrent, IntPtr actorNext)
+ private void OnFocusChanged(IntPtr viewCurrent, IntPtr viewNext)
{
FocusChangedEventArgs e = new FocusChangedEventArgs();
// Populate all members of "e" (FocusChangedEventArgs) with real data
- e.ActorCurrent = Actor.GetActorFromPtr(actorCurrent);
- e.ActorNext = Actor.GetActorFromPtr(actorNext);
+ e.ViewCurrent = View.GetViewFromPtr(viewCurrent);
+ e.ViewNext = View.GetViewFromPtr(viewNext);
if (_FocusManagerFocusChangedEventHandler != null)
{
}
// Callback for FocusManager FocusGroupChangedSignal
- private void OnFocusGroupChanged(IntPtr currentFocusedActor, bool forwardDirection)
+ private void OnFocusGroupChanged(IntPtr currentFocusedView, bool forwardDirection)
{
FocusGroupChangedEventArgs e = new FocusGroupChangedEventArgs();
// Populate all members of "e" (FocusGroupChangedEventArgs) with real data
- e.CurrentFocusedActor = Actor.GetActorFromPtr(currentFocusedActor);
+ e.CurrentFocusedView = View.GetViewFromPtr(currentFocusedView);
e.ForwardDirection = forwardDirection;
if (_FocusManagerFocusGroupChangedEventHandler != null)
}
/**
- * @brief Event for FocusedActorEnterKeyPressed signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of FocusedActorEnterKeyEventHandler) provided by the user.
- * FocusedActorEnterKeyPressed signal is emitted when the current focused actor has the enter key pressed on it.
+ * @brief Event for FocusedViewEnterKeyPressed signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of FocusedViewEnterKeyEventHandler) provided by the user.
+ * FocusedViewEnterKeyPressed signal is emitted when the current focused view has the enter key pressed on it.
*/
- public event FocusedActorEnterKeyEventHandler FocusedActorEnterKeyPressed
+ public event FocusedViewEnterKeyEventHandler FocusedViewEnterKeyPressed
{
add
{
lock(this)
{
// Restricted to only one listener
- if (_FocusManagerFocusedActorEnterKeyEventHandler == null)
+ if (_FocusManagerFocusedViewEnterKeyEventHandler == null)
{
- _FocusManagerFocusedActorEnterKeyEventHandler += value;
+ _FocusManagerFocusedViewEnterKeyEventHandler += value;
- _FocusManagerFocusedActorEnterKeyEventCallbackDelegate = new FocusedActorEnterKeyEventCallbackDelegate(OnFocusedActorEnterKey);
- this.FocusedActorEnterKeySignal().Connect(_FocusManagerFocusedActorEnterKeyEventCallbackDelegate);
+ _FocusManagerFocusedViewEnterKeyEventCallbackDelegate = new FocusedViewEnterKeyEventCallbackDelegate(OnFocusedViewEnterKey);
+ this.FocusedViewEnterKeySignal().Connect(_FocusManagerFocusedViewEnterKeyEventCallbackDelegate);
}
}
}
{
lock(this)
{
- if (_FocusManagerFocusedActorEnterKeyEventHandler != null)
+ if (_FocusManagerFocusedViewEnterKeyEventHandler != null)
{
- this.FocusedActorEnterKeySignal().Disconnect(_FocusManagerFocusedActorEnterKeyEventCallbackDelegate);
+ this.FocusedViewEnterKeySignal().Disconnect(_FocusManagerFocusedViewEnterKeyEventCallbackDelegate);
}
- _FocusManagerFocusedActorEnterKeyEventHandler -= value;
+ _FocusManagerFocusedViewEnterKeyEventHandler -= value;
}
}
}
- // Callback for FocusManager FocusedActorEnterKeySignal
- private void OnFocusedActorEnterKey(IntPtr actor)
+ // Callback for FocusManager FocusedViewEnterKeySignal
+ private void OnFocusedViewEnterKey(IntPtr view)
{
- FocusedActorEnterKeyEventArgs e = new FocusedActorEnterKeyEventArgs();
+ FocusedViewEnterKeyEventArgs e = new FocusedViewEnterKeyEventArgs();
- // Populate all members of "e" (FocusedActorEnterKeyEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
+ // Populate all members of "e" (FocusedViewEnterKeyEventArgs) with real data
+ e.View = View.GetViewFromPtr(view);
- if (_FocusManagerFocusedActorEnterKeyEventHandler != null)
+ if (_FocusManagerFocusedViewEnterKeyEventHandler != null)
{
//here we send all data to user event handlers
- _FocusManagerFocusedActorEnterKeyEventHandler(this, e);
+ _FocusManagerFocusedViewEnterKeyEventHandler(this, e);
}
}
return ret;
}
- public bool SetCurrentFocusActor(Actor actor) {
- bool ret = NDalicManualPINVOKE.FocusManager_SetCurrentFocusActor(swigCPtr, Actor.getCPtr(actor));
+ public bool SetCurrentFocusView(View view) {
+ bool ret = NDalicManualPINVOKE.FocusManager_SetCurrentFocusActor(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor GetCurrentFocusActor() {
- Actor ret = new Actor(NDalicManualPINVOKE.FocusManager_GetCurrentFocusActor(swigCPtr), true);
+ public View GetCurrentFocusView() {
+ View ret = new View(NDalicManualPINVOKE.FocusManager_GetCurrentFocusActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public void SetAsFocusGroup(Actor actor, bool isFocusGroup) {
- NDalicManualPINVOKE.FocusManager_SetAsFocusGroup(swigCPtr, Actor.getCPtr(actor), isFocusGroup);
+ public void SetAsFocusGroup(View view, bool isFocusGroup) {
+ NDalicManualPINVOKE.FocusManager_SetAsFocusGroup(swigCPtr, View.getCPtr(view), isFocusGroup);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public bool IsFocusGroup(Actor actor) {
- bool ret = NDalicManualPINVOKE.FocusManager_IsFocusGroup(swigCPtr, Actor.getCPtr(actor));
+ public bool IsFocusGroup(View view) {
+ bool ret = NDalicManualPINVOKE.FocusManager_IsFocusGroup(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor GetFocusGroup(Actor actor) {
- Actor ret = new Actor(NDalicManualPINVOKE.FocusManager_GetFocusGroup(swigCPtr, Actor.getCPtr(actor)), true);
+ public View GetFocusGroup(View view) {
+ View ret = new View(NDalicManualPINVOKE.FocusManager_GetFocusGroup(swigCPtr, View.getCPtr(view)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public void SetFocusIndicatorActor(Actor indicator) {
- NDalicManualPINVOKE.FocusManager_SetFocusIndicatorActor(swigCPtr, Actor.getCPtr(indicator));
+ public void SetFocusIndicatorView(View indicator) {
+ NDalicManualPINVOKE.FocusManager_SetFocusIndicatorActor(swigCPtr, View.getCPtr(indicator));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetFocusIndicatorActor() {
- Actor ret = new Actor(NDalicManualPINVOKE.FocusManager_GetFocusIndicatorActor(swigCPtr), true);
+ public View GetFocusIndicatorView() {
+ View ret = new View(NDalicManualPINVOKE.FocusManager_GetFocusIndicatorActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public ActorSignal FocusedActorEnterKeySignal() {
- ActorSignal ret = new ActorSignal(NDalicManualPINVOKE.FocusManager_FocusedActorEnterKeySignal(swigCPtr), false);
+ public ViewSignal FocusedViewEnterKeySignal() {
+ ViewSignal ret = new ViewSignal(NDalicManualPINVOKE.FocusManager_FocusedActorEnterKeySignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public interface ICustomFocusAlgorithm
{
- View GetNextFocusableActor(View current, View proposed, View.KeyboardFocus.Direction direction);
+ View GetNextFocusableView(View current, View proposed, View.KeyboardFocus.Direction direction);
}
private class CustomAlgorithmInterfaceWrapper : CustomAlgorithmInterface
_customFocusAlgorithm = customFocusAlgorithm;
}
- public override Actor GetNextFocusableActor(Actor current, Actor proposed, View.KeyboardFocus.Direction direction)
+ public override View GetNextFocusableView(View current, View proposed, View.KeyboardFocus.Direction direction)
{
View currentView = View.DownCast<View>(current);
View proposedView = View.DownCast<View>(proposed);
- return _customFocusAlgorithm.GetNextFocusableActor(currentView, proposedView, direction);
+ return _customFocusAlgorithm.GetNextFocusableView(currentView, proposedView, direction);
}
}
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public new void Add(Actor child) {
- NDalicPINVOKE.GaussianBlurView_Add(swigCPtr, Actor.getCPtr(child));
+ public new void Add(View child) {
+ NDalicPINVOKE.GaussianBlurView_Add(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public new void Remove(Actor child) {
- NDalicPINVOKE.GaussianBlurView_Remove(swigCPtr, Actor.getCPtr(child));
+ public new void Remove(View child) {
+ NDalicPINVOKE.GaussianBlurView_Remove(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
namespace Dali {
-public class GestureDetector : Handle {
+public class GestureDetector : BaseHandle {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal GestureDetector(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.GestureDetector_SWIGUpcast(cPtr), cMemoryOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public void Attach(Actor actor) {
- NDalicPINVOKE.GestureDetector_Attach(swigCPtr, Actor.getCPtr(actor));
+ public void Attach(View view) {
+ NDalicPINVOKE.GestureDetector_Attach(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void Detach(Actor actor) {
- NDalicPINVOKE.GestureDetector_Detach(swigCPtr, Actor.getCPtr(actor));
+ public void Detach(View view) {
+ NDalicPINVOKE.GestureDetector_Detach(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public uint GetAttachedActorCount() {
+ public uint GetAttachedViewCount() {
uint ret = NDalicPINVOKE.GestureDetector_GetAttachedActorCount(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor GetAttachedActor(uint index) {
- Actor ret = new Actor(NDalicPINVOKE.GestureDetector_GetAttachedActor(swigCPtr, index), true);
+ public View GetAttachedView(uint index) {
+ View ret = new View(NDalicPINVOKE.GestureDetector_GetAttachedActor(swigCPtr, index), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return PointStateType.FINISHED;
}
- public Actor GetHitActor(uint point) {
+ public View GetHitView(uint point) {
if( point < points.Count )
{
- return points[(int)point].hitActor;
+ return points[(int)point].hitView;
}
else
{
// Return a native empty handle
- Actor actor = new Actor();
- actor.Reset();
- return actor;
+ View view = new View();
+ view.Reset();
+ return view;
}
}
namespace Dali {
-public class ActorHoverSignal : global::System.IDisposable {
+internal class HoverSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal ActorHoverSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ internal HoverSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ActorHoverSignal obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(HoverSignal obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~ActorHoverSignal() {
+ ~HoverSignal() {
DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public bool Emit(Actor arg1, Hover arg2) {
- bool ret = NDalicPINVOKE.ActorHoverSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Hover.getCPtr(arg2));
+ public bool Emit(View arg1, Hover arg2) {
+ bool ret = NDalicPINVOKE.ActorHoverSignal_Emit(swigCPtr, View.getCPtr(arg1), Hover.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public ActorHoverSignal() : this(NDalicPINVOKE.new_ActorHoverSignal(), true) {
+ public HoverSignal() : this(NDalicPINVOKE.new_ActorHoverSignal(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Item(uint t, Actor u) : this(NDalicPINVOKE.new_Item__SWIG_1(t, Actor.getCPtr(u)), true) {
+ public Item(uint t, View u) : this(NDalicPINVOKE.new_Item__SWIG_1(t, View.getCPtr(u)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
}
- public Actor second {
+ public View second {
set {
- NDalicPINVOKE.Item_second_set(swigCPtr, Actor.getCPtr(value));
+ NDalicPINVOKE.Item_second_set(swigCPtr, View.getCPtr(value));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get {
global::System.IntPtr cPtr = NDalicPINVOKE.Item_second_get(swigCPtr);
- Actor ret = (cPtr == global::System.IntPtr.Zero) ? null : new Actor(cPtr, false);
+ View ret = (cPtr == global::System.IntPtr.Zero) ? null : new View(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public virtual Actor NewItem(uint itemId) {
- Actor ret = new Actor(NDalicPINVOKE.ItemFactory_NewItem(swigCPtr, itemId), true);
+ public virtual View NewItem(uint itemId) {
+ View ret = new View(NDalicPINVOKE.ItemFactory_NewItem(swigCPtr, itemId), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public virtual void ItemReleased(uint itemId, Actor actor) {
- if (SwigDerivedClassHasMethod("ItemReleased", swigMethodTypes2)) NDalicPINVOKE.ItemFactory_ItemReleasedSwigExplicitItemFactory(swigCPtr, itemId, Actor.getCPtr(actor)); else NDalicPINVOKE.ItemFactory_ItemReleased(swigCPtr, itemId, Actor.getCPtr(actor));
+ public virtual void ItemReleased(uint itemId, View view) {
+ if (SwigDerivedClassHasMethod("ItemReleased", swigMethodTypes2)) NDalicPINVOKE.ItemFactory_ItemReleasedSwigExplicitItemFactory(swigCPtr, itemId, View.getCPtr(view)); else NDalicPINVOKE.ItemFactory_ItemReleased(swigCPtr, itemId, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
private global::System.IntPtr SwigDirectorNewItem(uint itemId) {
- return Actor.getCPtr(NewItem(itemId)).Handle;
+ return View.getCPtr(NewItem(itemId)).Handle;
}
private void SwigDirectorItemReleased(uint itemId, global::System.IntPtr actor) {
- ItemReleased(itemId, new Actor(actor, true));
+ ItemReleased(itemId, new View(actor, true));
}
public delegate uint SwigDelegateItemFactory_0();
private static global::System.Type[] swigMethodTypes0 = new global::System.Type[] { };
private static global::System.Type[] swigMethodTypes1 = new global::System.Type[] { typeof(uint) };
- private static global::System.Type[] swigMethodTypes2 = new global::System.Type[] { typeof(uint), typeof(Actor) };
+ private static global::System.Type[] swigMethodTypes2 = new global::System.Type[] { typeof(uint), typeof(View) };
}
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public virtual void ApplyConstraints(Actor actor, int itemId, Vector3 layoutSize, Actor itemViewActor) {
- NDalicPINVOKE.ItemLayout_ApplyConstraints(swigCPtr, Actor.getCPtr(actor), itemId, Vector3.getCPtr(layoutSize), Actor.getCPtr(itemViewActor));
+ public virtual void ApplyConstraints(View view, int itemId, Vector3 layoutSize, View itemView) {
+ NDalicPINVOKE.ItemLayout_ApplyConstraints(swigCPtr, View.getCPtr(view), itemId, Vector3.getCPtr(layoutSize), View.getCPtr(itemView));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetItem(uint itemId) {
- Actor ret = new Actor(NDalicPINVOKE.ItemView_GetItem(swigCPtr, itemId), true);
+ public View GetItem(uint itemId) {
+ View ret = new View(NDalicPINVOKE.ItemView_GetItem(swigCPtr, itemId), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public uint GetItemId(Actor actor) {
- uint ret = NDalicPINVOKE.ItemView_GetItemId(swigCPtr, Actor.getCPtr(actor));
+ public uint GetItemId(View view) {
+ uint ret = NDalicPINVOKE.ItemView_GetItemId(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public Actor Emit(Actor arg1, Actor arg2, View.KeyboardFocus.Direction arg3) {
- Actor ret = new Actor(NDalicManualPINVOKE.PreFocusChangeSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Actor.getCPtr(arg2), (int)arg3), true);
+ public View Emit(View arg1, View arg2, View.KeyboardFocus.Direction arg3) {
+ View ret = new View(NDalicManualPINVOKE.PreFocusChangeSignal_Emit(swigCPtr, View.getCPtr(arg1), View.getCPtr(arg2), (int)arg3), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
* limitations under the License.
*
*/
-// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.10
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Dali {
-
-public class Layer : Actor {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
- internal Layer(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Layer_SWIGUpcast(cPtr), cMemoryOwn) {
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
-
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Layer obj) {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
-
- ~Layer() {
- DisposeQueue.Instance.Add(this);
- }
-
- public override void Dispose() {
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_Layer(swigCPtr);
+namespace Dali
+{
+
+ public class Layer : Animatable
+ {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+
+ internal Layer(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Layer_SWIGUpcast(cPtr), cMemoryOwn)
+ {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- base.Dispose();
- }
- }
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Layer obj)
+ {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
- public class Property : global::System.IDisposable {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- protected bool swigCMemOwn;
-
- internal Property(global::System.IntPtr cPtr, bool cMemoryOwn) {
- swigCMemOwn = cMemoryOwn;
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
-
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj) {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
-
- ~Property() {
- Dispose();
- }
-
- public virtual void Dispose() {
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_Layer_Property(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-
- public Property() : this(NDalicPINVOKE.new_Layer_Property(), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public static readonly int CLIPPING_ENABLE = NDalicPINVOKE.Layer_Property_CLIPPING_ENABLE_get();
- public static readonly int CLIPPING_BOX = NDalicPINVOKE.Layer_Property_CLIPPING_BOX_get();
- public static readonly int BEHAVIOR = NDalicPINVOKE.Layer_Property_BEHAVIOR_get();
-
- }
-
- public Layer () : this (NDalicPINVOKE.Layer_New(), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-
- }
- public new static Layer DownCast(BaseHandle handle) {
- Layer ret = new Layer(NDalicPINVOKE.Layer_DownCast(BaseHandle.getCPtr(handle)), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Layer(Layer copy) : this(NDalicPINVOKE.new_Layer__SWIG_1(Layer.getCPtr(copy)), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Layer Assign(Layer rhs) {
- Layer ret = new Layer(NDalicPINVOKE.Layer_Assign(swigCPtr, Layer.getCPtr(rhs)), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public uint GetDepth() {
- uint ret = NDalicPINVOKE.Layer_GetDepth(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void Raise() {
- NDalicPINVOKE.Layer_Raise(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Lower() {
- NDalicPINVOKE.Layer_Lower(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void RaiseAbove(Layer target) {
- NDalicPINVOKE.Layer_RaiseAbove(swigCPtr, Layer.getCPtr(target));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void LowerBelow(Layer target) {
- NDalicPINVOKE.Layer_LowerBelow(swigCPtr, Layer.getCPtr(target));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void RaiseToTop() {
- NDalicPINVOKE.Layer_RaiseToTop(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void LowerToBottom() {
- NDalicPINVOKE.Layer_LowerToBottom(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void MoveAbove(Layer target) {
- NDalicPINVOKE.Layer_MoveAbove(swigCPtr, Layer.getCPtr(target));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void MoveBelow(Layer target) {
- NDalicPINVOKE.Layer_MoveBelow(swigCPtr, Layer.getCPtr(target));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetBehavior(Layer.LayerBehavior behavior) {
- NDalicPINVOKE.Layer_SetBehavior(swigCPtr, (int)behavior);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Layer.LayerBehavior GetBehavior() {
- Layer.LayerBehavior ret = (Layer.LayerBehavior)NDalicPINVOKE.Layer_GetBehavior(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetClipping(bool enabled) {
- NDalicPINVOKE.Layer_SetClipping(swigCPtr, enabled);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public bool IsClipping() {
- bool ret = NDalicPINVOKE.Layer_IsClipping(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetClippingBox(int x, int y, int width, int height) {
- NDalicPINVOKE.Layer_SetClippingBox__SWIG_0(swigCPtr, x, y, width, height);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetClippingBox(Rectangle box) {
- NDalicPINVOKE.Layer_SetClippingBox__SWIG_1(swigCPtr, Rectangle.getCPtr(box));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Rectangle GetClippingBox() {
- Rectangle ret = new Rectangle(NDalicPINVOKE.Layer_GetClippingBox(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetDepthTestDisabled(bool disable) {
- NDalicPINVOKE.Layer_SetDepthTestDisabled(swigCPtr, disable);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public bool IsDepthTestDisabled() {
- bool ret = NDalicPINVOKE.Layer_IsDepthTestDisabled(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetSortFunction(SWIGTYPE_p_f_r_q_const__Dali__Vector3__float function) {
- NDalicPINVOKE.Layer_SetSortFunction(swigCPtr, SWIGTYPE_p_f_r_q_const__Dali__Vector3__float.getCPtr(function));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetTouchConsumed(bool consume) {
- NDalicPINVOKE.Layer_SetTouchConsumed(swigCPtr, consume);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public bool IsTouchConsumed() {
- bool ret = NDalicPINVOKE.Layer_IsTouchConsumed(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetHoverConsumed(bool consume) {
- NDalicPINVOKE.Layer_SetHoverConsumed(swigCPtr, consume);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public bool IsHoverConsumed() {
- bool ret = NDalicPINVOKE.Layer_IsHoverConsumed(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public enum LayerBehavior {
- LAYER_2D,
- LAYER_UI = LAYER_2D,
- LAYER_3D
- }
-
- public enum TreeDepthMultiplier {
- TREE_DEPTH_MULTIPLIER = 10000
- }
-
- public bool ClippingEnable
- {
- get
- {
- bool temp = false;
- GetProperty( Layer.Property.CLIPPING_ENABLE).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Layer.Property.CLIPPING_ENABLE, new Dali.Property.Value( value ) );
- }
- }
- public Rectangle ClippingBox
- {
- get
- {
- Rectangle temp = new Rectangle(0,0,0,0);
- GetProperty( Layer.Property.CLIPPING_BOX).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( Layer.Property.CLIPPING_BOX, new Dali.Property.Value( value ) );
- }
- }
- public Layer.LayerBehavior Behavior
- {
- get
- {
- return GetBehavior();
- }
- set
- {
- SetBehavior( value );
- }
- }
+ ~Layer()
+ {
+ DisposeQueue.Instance.Add(this);
+ }
-}
+ public virtual void Dispose()
+ {
+ if (!Window.IsInstalled())
+ {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
+ lock (this)
+ {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero)
+ {
+ if (swigCMemOwn)
+ {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_Layer(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
+
+
+ public class Property : global::System.IDisposable
+ {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
+ {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
+ {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~Property()
+ {
+ Dispose();
+ }
+
+ public virtual void Dispose()
+ {
+ lock (this)
+ {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero)
+ {
+ if (swigCMemOwn)
+ {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_Layer_Property(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
+
+ public Property() : this(NDalicPINVOKE.new_Layer_Property(), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public static readonly int CLIPPING_ENABLE = NDalicPINVOKE.Layer_Property_CLIPPING_ENABLE_get();
+ public static readonly int CLIPPING_BOX = NDalicPINVOKE.Layer_Property_CLIPPING_BOX_get();
+ public static readonly int BEHAVIOR = NDalicPINVOKE.Layer_Property_BEHAVIOR_get();
+
+ }
+
+ public Layer() : this(NDalicPINVOKE.Layer_New(), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+
+ }
+
+ public new static Layer DownCast(BaseHandle handle)
+ {
+ Layer ret = new Layer(NDalicPINVOKE.Layer_DownCast(BaseHandle.getCPtr(handle)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Layer(Layer copy) : this(NDalicPINVOKE.new_Layer__SWIG_1(Layer.getCPtr(copy)), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Layer Assign(Layer rhs)
+ {
+ Layer ret = new Layer(NDalicPINVOKE.Layer_Assign(swigCPtr, Layer.getCPtr(rhs)), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public View FindChildById(uint id)
+ {
+ View ret = new View(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void Add(View child)
+ {
+ NDalicPINVOKE.Actor_Add(swigCPtr, View.getCPtr(child));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Remove(View child)
+ {
+ NDalicPINVOKE.Actor_Remove(swigCPtr, View.getCPtr(child));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public uint GetDepth()
+ {
+ uint ret = NDalicPINVOKE.Layer_GetDepth(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void Raise()
+ {
+ NDalicPINVOKE.Layer_Raise(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Lower()
+ {
+ NDalicPINVOKE.Layer_Lower(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void RaiseAbove(Layer target)
+ {
+ NDalicPINVOKE.Layer_RaiseAbove(swigCPtr, Layer.getCPtr(target));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void LowerBelow(Layer target)
+ {
+ NDalicPINVOKE.Layer_LowerBelow(swigCPtr, Layer.getCPtr(target));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void RaiseToTop()
+ {
+ NDalicPINVOKE.Layer_RaiseToTop(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void LowerToBottom()
+ {
+ NDalicPINVOKE.Layer_LowerToBottom(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void MoveAbove(Layer target)
+ {
+ NDalicPINVOKE.Layer_MoveAbove(swigCPtr, Layer.getCPtr(target));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void MoveBelow(Layer target)
+ {
+ NDalicPINVOKE.Layer_MoveBelow(swigCPtr, Layer.getCPtr(target));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetBehavior(Layer.LayerBehavior behavior)
+ {
+ NDalicPINVOKE.Layer_SetBehavior(swigCPtr, (int)behavior);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Layer.LayerBehavior GetBehavior()
+ {
+ Layer.LayerBehavior ret = (Layer.LayerBehavior)NDalicPINVOKE.Layer_GetBehavior(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetClipping(bool enabled)
+ {
+ NDalicPINVOKE.Layer_SetClipping(swigCPtr, enabled);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool IsClipping()
+ {
+ bool ret = NDalicPINVOKE.Layer_IsClipping(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetClippingBox(int x, int y, int width, int height)
+ {
+ NDalicPINVOKE.Layer_SetClippingBox__SWIG_0(swigCPtr, x, y, width, height);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetClippingBox(Rectangle box)
+ {
+ NDalicPINVOKE.Layer_SetClippingBox__SWIG_1(swigCPtr, Rectangle.getCPtr(box));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Rectangle GetClippingBox()
+ {
+ Rectangle ret = new Rectangle(NDalicPINVOKE.Layer_GetClippingBox(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetDepthTestDisabled(bool disable)
+ {
+ NDalicPINVOKE.Layer_SetDepthTestDisabled(swigCPtr, disable);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool IsDepthTestDisabled()
+ {
+ bool ret = NDalicPINVOKE.Layer_IsDepthTestDisabled(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetSortFunction(SWIGTYPE_p_f_r_q_const__Dali__Vector3__float function)
+ {
+ NDalicPINVOKE.Layer_SetSortFunction(swigCPtr, SWIGTYPE_p_f_r_q_const__Dali__Vector3__float.getCPtr(function));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetTouchConsumed(bool consume)
+ {
+ NDalicPINVOKE.Layer_SetTouchConsumed(swigCPtr, consume);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool IsTouchConsumed()
+ {
+ bool ret = NDalicPINVOKE.Layer_IsTouchConsumed(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetHoverConsumed(bool consume)
+ {
+ NDalicPINVOKE.Layer_SetHoverConsumed(swigCPtr, consume);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool IsHoverConsumed()
+ {
+ bool ret = NDalicPINVOKE.Layer_IsHoverConsumed(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public enum LayerBehavior
+ {
+ LAYER_2D,
+ LAYER_UI = LAYER_2D,
+ LAYER_3D
+ }
+
+ public enum TreeDepthMultiplier
+ {
+ TREE_DEPTH_MULTIPLIER = 10000
+ }
+
+ public bool ClippingEnable
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(Layer.Property.CLIPPING_ENABLE).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(Layer.Property.CLIPPING_ENABLE, new Dali.Property.Value(value));
+ }
+ }
+
+ public Rectangle ClippingBox
+ {
+ get
+ {
+ Rectangle temp = new Rectangle(0, 0, 0, 0);
+ GetProperty(Layer.Property.CLIPPING_BOX).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(Layer.Property.CLIPPING_BOX, new Dali.Property.Value(value));
+ }
+ }
+
+ public Layer.LayerBehavior Behavior
+ {
+ get
+ {
+ return GetBehavior();
+ }
+ set
+ {
+ SetBehavior(value);
+ }
+ }
+
+ }
}
namespace Dali {
-public class LinearConstrainer : Handle {
+public class LinearConstrainer : BaseHandle {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal LinearConstrainer(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.LinearConstrainer_SWIGUpcast(cPtr), cMemoryOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void Remove(Handle target) {
- NDalicPINVOKE.LinearConstrainer_Remove(swigCPtr, Handle.getCPtr(target));
+ public void Remove(Animatable target) {
+ NDalicPINVOKE.LinearConstrainer_Remove(swigCPtr, Animatable.getCPtr(target));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get
{
Dali.Property.Array temp = new Dali.Property.Array();
- GetProperty( LinearConstrainer.Property.VALUE).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, LinearConstrainer.Property.VALUE).Get( temp );
return temp;
}
set
{
- SetProperty( LinearConstrainer.Property.VALUE, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, LinearConstrainer.Property.VALUE, new Dali.Property.Value( value ) );
}
}
public Dali.Property.Array Progress
get
{
Dali.Property.Array temp = new Dali.Property.Array();
- GetProperty( LinearConstrainer.Property.PROGRESS).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, LinearConstrainer.Property.PROGRESS).Get( temp );
return temp;
}
set
{
- SetProperty( LinearConstrainer.Property.PROGRESS, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, LinearConstrainer.Property.PROGRESS, new Dali.Property.Value( value ) );
}
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, LongPressGesture arg2) {
- NDalicPINVOKE.LongPressGestureDetectedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), LongPressGesture.getCPtr(arg2));
+ public void Emit(View arg1, LongPressGesture arg2) {
+ NDalicPINVOKE.LongPressGestureDetectedSignal_Emit(swigCPtr, View.getCPtr(arg1), LongPressGesture.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public class DetectedEventArgs : EventArgs
{
- private Actor _actor;
+ private View _view;
private LongPressGesture _longPressGesture;
- public Actor Actor
+ public View View
{
get
{
- return _actor;
+ return _view;
}
set
{
- _actor = value;
+ _view = value;
}
}
DetectedEventArgs e = new DetectedEventArgs();
// Populate all members of "e" (LongPressGestureEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
+ e.View = View.GetViewFromPtr(actor);
e.LongPressGesture = Dali.LongPressGesture.GetLongPressGestureFromPtr(longPressGesture);
if (_longPressGestureEventHandler != null)
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public static Handle New() {
- Handle ret = new Handle(NDalicPINVOKE.New(), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
public static bool RegisterType(string name, SWIGTYPE_p_std__type_info baseType, System.Delegate f) {
System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(f);
{
}
}
- public static void UnparentAndReset(Actor actor) {
- NDalicPINVOKE.UnparentAndReset(Actor.getCPtr(actor));
+ public static void UnparentAndReset(View view) {
+ NDalicPINVOKE.UnparentAndReset(View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void Raise(Actor actor) {
- NDalicPINVOKE.Raise(Actor.getCPtr(actor));
+ public static void Raise(View view) {
+ NDalicPINVOKE.Raise(View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void Lower(Actor actor) {
- NDalicPINVOKE.Lower(Actor.getCPtr(actor));
+ public static void Lower(View view) {
+ NDalicPINVOKE.Lower(View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void RaiseToTop(Actor actor) {
- NDalicPINVOKE.RaiseToTop(Actor.getCPtr(actor));
+ public static void RaiseToTop(View view) {
+ NDalicPINVOKE.RaiseToTop(View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void LowerToBottom(Actor actor) {
- NDalicPINVOKE.LowerToBottom(Actor.getCPtr(actor));
+ public static void LowerToBottom(View view) {
+ NDalicPINVOKE.LowerToBottom(View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void RaiseAbove(Actor actor, Actor target) {
- NDalicPINVOKE.RaiseAbove(Actor.getCPtr(actor), Actor.getCPtr(target));
+ public static void RaiseAbove(View view, View target) {
+ NDalicPINVOKE.RaiseAbove(View.getCPtr(view), View.getCPtr(target));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void LowerBelow(Actor actor, Actor target) {
- NDalicPINVOKE.LowerBelow(Actor.getCPtr(actor), Actor.getCPtr(target));
+ public static void LowerBelow(View view, View target) {
+ NDalicPINVOKE.LowerBelow(View.getCPtr(view), View.getCPtr(target));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
}
- public static WindowFocusSignalType FocusChangedSignal(Window window) {
- WindowFocusSignalType ret = new WindowFocusSignalType(NDalicPINVOKE.FocusChangedSignal(Window.getCPtr(window)), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public static void SetAcceptFocus(Window window, bool accept) {
- NDalicPINVOKE.SetAcceptFocus(Window.getCPtr(window), accept);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public static bool IsFocusAcceptable(Window window) {
- bool ret = NDalicPINVOKE.IsFocusAcceptable(Window.getCPtr(window));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public static void Show(Window window) {
- NDalicPINVOKE.Show(Window.getCPtr(window));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public static void Hide(Window window) {
- NDalicPINVOKE.Hide(Window.getCPtr(window));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public static bool IsVisible(Window window) {
- bool ret = NDalicPINVOKE.IsVisible(Window.getCPtr(window));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
public static ViewImpl GetImplementation(View handle) {
ViewImpl ret = new ViewImpl(NDalicPINVOKE.GetImplementation__SWIG_0(View.getCPtr(handle)), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public static void MoveActorConstraint(Vector3 current, SWIGTYPE_p_PropertyInputContainer inputs) {
- NDalicPINVOKE.MoveActorConstraint(Vector3.getCPtr(current), SWIGTYPE_p_PropertyInputContainer.getCPtr(inputs));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public static void WrapActorConstraint(Vector3 position, SWIGTYPE_p_PropertyInputContainer inputs) {
- NDalicPINVOKE.WrapActorConstraint(Vector3.getCPtr(position), SWIGTYPE_p_PropertyInputContainer.getCPtr(inputs));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
public static uint DEFAULT_RENDERING_BACKEND {
get {
uint ret = NDalicPINVOKE.DEFAULT_RENDERING_BACKEND_get();
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
--- /dev/null
+/** Copyright (c) 2017 Samsung Electronics Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+*/
+
+/**
+ * Static Helper class for Property
+ * Internal
+ */
+
+namespace Dali
+{
+
+public static class Object
+{
+ public static Property.Value GetProperty(global::System.Runtime.InteropServices.HandleRef handle, int index) {
+ Property.Value ret = new Property.Value(NDalicPINVOKE.Handle_GetProperty(handle, index), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public static void SetProperty( global::System.Runtime.InteropServices.HandleRef handle, int index, Property.Value propertyValue)
+ {
+ NDalicPINVOKE.Handle_SetProperty(handle, index, Property.Value.getCPtr(propertyValue));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+}
+
+}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, PanGesture arg2) {
- NDalicPINVOKE.PanGestureDetectedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), PanGesture.getCPtr(arg2));
+ public void Emit(View arg1, PanGesture arg2) {
+ NDalicPINVOKE.PanGestureDetectedSignal_Emit(swigCPtr, View.getCPtr(arg1), PanGesture.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public class DetectedEventArgs : EventArgs
{
- private Actor _actor;
+ private View _view;
private PanGesture _panGesture;
- public Actor Actor
+ public View View
{
get
{
- return _actor;
+ return _view;
}
set
{
- _actor = value;
+ _view = value;
}
}
DetectedEventArgs e = new DetectedEventArgs();
// Populate all members of "e" (PanGestureEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
+ e.View = View.GetViewFromPtr(actor);
e.PanGesture = Dali.PanGesture.GetPanGestureFromPtr(panGesture);
if (_panGestureEventHandler != null)
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.SCREEN_POSITION).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, PanGestureDetector.Property.SCREEN_POSITION).Get( temp );
return temp;
}
} public Vector2 ScreenDisplacement
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.SCREEN_DISPLACEMENT).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, PanGestureDetector.Property.SCREEN_DISPLACEMENT).Get( temp );
return temp;
}
} public Vector2 ScreenVelocity
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.SCREEN_VELOCITY).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, PanGestureDetector.Property.SCREEN_VELOCITY).Get( temp );
return temp;
}
} public Vector2 LocalPosition
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.LOCAL_POSITION).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, PanGestureDetector.Property.LOCAL_POSITION).Get( temp );
return temp;
}
} public Vector2 LocalDisplacement
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.LOCAL_DISPLACEMENT).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, PanGestureDetector.Property.LOCAL_DISPLACEMENT).Get( temp );
return temp;
}
} public Vector2 LocalVelocity
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.LOCAL_VELOCITY).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, PanGestureDetector.Property.LOCAL_VELOCITY).Get( temp );
return temp;
}
} public bool Panning
get
{
bool temp = false;
- GetProperty( PanGestureDetector.Property.PANNING).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, PanGestureDetector.Property.PANNING).Get( ref temp );
return temp;
}
}
namespace Dali {
-public class Path : Handle {
+public class Path : BaseHandle {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal Path(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Path_SWIGUpcast(cPtr), cMemoryOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
get
{
Dali.Property.Array temp = new Dali.Property.Array();
- GetProperty( Path.Property.POINTS).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, Path.Property.POINTS).Get( temp );
return temp;
}
set
{
- SetProperty( Path.Property.POINTS, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Path.Property.POINTS, new Dali.Property.Value( value ) );
}
}
public Dali.Property.Array ControlPoints
get
{
Dali.Property.Array temp = new Dali.Property.Array();
- GetProperty( Path.Property.CONTROL_POINTS).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, Path.Property.CONTROL_POINTS).Get( temp );
return temp;
}
set
{
- SetProperty( Path.Property.CONTROL_POINTS, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Path.Property.CONTROL_POINTS, new Dali.Property.Value( value ) );
}
}
namespace Dali {
-public class PathConstrainer : Handle {
+public class PathConstrainer : BaseHandle {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal PathConstrainer(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.PathConstrainer_SWIGUpcast(cPtr), cMemoryOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void Remove(Handle target) {
- NDalicPINVOKE.PathConstrainer_Remove(swigCPtr, Handle.getCPtr(target));
+ public void Remove(Animatable target) {
+ NDalicPINVOKE.PathConstrainer_Remove(swigCPtr, Animatable.getCPtr(target));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get
{
Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
- GetProperty( PathConstrainer.Property.FORWARD).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, PathConstrainer.Property.FORWARD).Get( temp );
return temp;
}
set
{
- SetProperty( PathConstrainer.Property.FORWARD, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, PathConstrainer.Property.FORWARD, new Dali.Property.Value( value ) );
}
}
public Dali.Property.Array Points
get
{
Dali.Property.Array temp = new Dali.Property.Array();
- GetProperty( PathConstrainer.Property.POINTS).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, PathConstrainer.Property.POINTS).Get( temp );
return temp;
}
set
{
- SetProperty( PathConstrainer.Property.POINTS, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, PathConstrainer.Property.POINTS, new Dali.Property.Value( value ) );
}
}
public Dali.Property.Array ControlPoints
get
{
Dali.Property.Array temp = new Dali.Property.Array();
- GetProperty( PathConstrainer.Property.CONTROL_POINTS).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, PathConstrainer.Property.CONTROL_POINTS).Get( temp );
return temp;
}
set
{
- SetProperty( PathConstrainer.Property.CONTROL_POINTS, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, PathConstrainer.Property.CONTROL_POINTS, new Dali.Property.Value( value ) );
}
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, PinchGesture arg2) {
- NDalicPINVOKE.PinchGestureDetectedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), PinchGesture.getCPtr(arg2));
+ public void Emit(View arg1, PinchGesture arg2) {
+ NDalicPINVOKE.PinchGestureDetectedSignal_Emit(swigCPtr, View.getCPtr(arg1), PinchGesture.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public class DetectedEventArgs : EventArgs
{
- private Actor _actor;
+ private View _view;
private PinchGesture _pinchGesture;
- public Actor Actor
+ public View View
{
get
{
- return _actor;
+ return _view;
}
set
{
- _actor = value;
+ _view = value;
}
}
DetectedEventArgs e = new DetectedEventArgs();
// Populate all members of "e" (DetectedEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
+ e.View = View.GetViewFromPtr(actor);
e.PinchGesture = Dali.PinchGesture.GetPinchGestureFromPtr(pinchGesture);
if (_pinchGestureEventHandler != null)
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public void SetTitle(Actor titleActor) {
- NDalicPINVOKE.Popup_SetTitle(swigCPtr, Actor.getCPtr(titleActor));
+ public void SetTitle(View titleView) {
+ NDalicPINVOKE.Popup_SetTitle(swigCPtr, View.getCPtr(titleView));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetTitle() {
- Actor ret = new Actor(NDalicPINVOKE.Popup_GetTitle(swigCPtr), true);
+ public View GetTitle() {
+ View ret = new View(NDalicPINVOKE.Popup_GetTitle(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public void SetContent(Actor content) {
- NDalicPINVOKE.Popup_SetContent(swigCPtr, Actor.getCPtr(content));
+ public void SetContent(View content) {
+ NDalicPINVOKE.Popup_SetContent(swigCPtr, View.getCPtr(content));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetContent() {
- Actor ret = new Actor(NDalicPINVOKE.Popup_GetContent(swigCPtr), true);
+ public View GetContent() {
+ View ret = new View(NDalicPINVOKE.Popup_GetContent(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public void SetFooter(Actor footer) {
- NDalicPINVOKE.Popup_SetFooter(swigCPtr, Actor.getCPtr(footer));
+ public void SetFooter(View footer) {
+ NDalicPINVOKE.Popup_SetFooter(swigCPtr, View.getCPtr(footer));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetFooter() {
- Actor ret = new Actor(NDalicPINVOKE.Popup_GetFooter(swigCPtr), true);
+ public View GetFooter() {
+ View ret = new View(NDalicPINVOKE.Popup_GetFooter(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public Property(Handle arg0, int propertyIndex) : this(NDalicPINVOKE.new_Property__SWIG_0(Handle.getCPtr(arg0), propertyIndex), true) {
+ public Property(Animatable arg0, int propertyIndex) : this(NDalicPINVOKE.new_Property__SWIG_0(Animatable.getCPtr(arg0), propertyIndex), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Property(Handle arg0, int propertyIndex, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_1(Handle.getCPtr(arg0), propertyIndex, componentIndex), true) {
+ public Property(Animatable arg0, int propertyIndex, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_1(Animatable.getCPtr(arg0), propertyIndex, componentIndex), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Property(Handle arg0, string propertyName) : this(NDalicPINVOKE.new_Property__SWIG_2(Handle.getCPtr(arg0), propertyName), true) {
+ public Property(Animatable arg0, string propertyName) : this(NDalicPINVOKE.new_Property__SWIG_2(Animatable.getCPtr(arg0), propertyName), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Property(Handle arg0, string propertyName, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_3(Handle.getCPtr(arg0), propertyName, componentIndex), true) {
+ public Property(Animatable arg0, string propertyName, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_3(Animatable.getCPtr(arg0), propertyName, componentIndex), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Handle _object {
+ public Animatable _object {
set {
- NDalicPINVOKE.Property__object_set(swigCPtr, Handle.getCPtr(value));
+ NDalicPINVOKE.Property__object_set(swigCPtr, Animatable.getCPtr(value));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
+ }
get {
- Handle ret = new Handle(NDalicPINVOKE.Property__object_get(swigCPtr), false);
+ Animatable ret = new Animatable(NDalicPINVOKE.Property__object_get(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
- }
+ }
}
public int propertyIndex {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public Handle GetTarget() {
- Handle ret = new Handle(NDalicPINVOKE.PropertyNotification_GetTarget(swigCPtr), true);
+ public Animatable GetTarget() {
+ Animatable ret = new Animatable(NDalicPINVOKE.PropertyNotification_GetTarget(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetButtonImage(Actor image) {
- NDalicPINVOKE.PushButton_SetButtonImage__SWIG_1(swigCPtr, Actor.getCPtr(image));
+ public void SetButtonImage(View image) {
+ NDalicPINVOKE.PushButton_SetButtonImage__SWIG_1(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetBackgroundImage(Actor image) {
- NDalicPINVOKE.PushButton_SetBackgroundImage(swigCPtr, Actor.getCPtr(image));
+ public void SetBackgroundImage(View image) {
+ NDalicPINVOKE.PushButton_SetBackgroundImage(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetSelectedImage(Actor image) {
- NDalicPINVOKE.PushButton_SetSelectedImage__SWIG_1(swigCPtr, Actor.getCPtr(image));
+ public void SetSelectedImage(View image) {
+ NDalicPINVOKE.PushButton_SetSelectedImage__SWIG_1(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetSelectedBackgroundImage(Actor image) {
- NDalicPINVOKE.PushButton_SetSelectedBackgroundImage(swigCPtr, Actor.getCPtr(image));
+ public void SetSelectedBackgroundImage(View image) {
+ NDalicPINVOKE.PushButton_SetSelectedBackgroundImage(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetDisabledBackgroundImage(Actor image) {
- NDalicPINVOKE.PushButton_SetDisabledBackgroundImage(swigCPtr, Actor.getCPtr(image));
+ public void SetDisabledBackgroundImage(View image) {
+ NDalicPINVOKE.PushButton_SetDisabledBackgroundImage(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetDisabledImage(Actor image) {
- NDalicPINVOKE.PushButton_SetDisabledImage(swigCPtr, Actor.getCPtr(image));
+ public void SetDisabledImage(View image) {
+ NDalicPINVOKE.PushButton_SetDisabledImage(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetDisabledSelectedImage(Actor image) {
- NDalicPINVOKE.PushButton_SetDisabledSelectedImage(swigCPtr, Actor.getCPtr(image));
+ public void SetDisabledSelectedImage(View image) {
+ NDalicPINVOKE.PushButton_SetDisabledSelectedImage(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
- public virtual void Add(Actor actor, Vector2 size) {
- NDalicPINVOKE.RelayoutContainer_Add(swigCPtr, Actor.getCPtr(actor), Vector2.getCPtr(size));
+ public virtual void Add(View view, Vector2 size) {
+ NDalicPINVOKE.RelayoutContainer_Add(swigCPtr, View.getCPtr(view), Vector2.getCPtr(size));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
namespace Dali {
-public class RenderTask : Handle {
+public class RenderTask : Animatable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal RenderTask(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.RenderTask_SWIGUpcast(cPtr), cMemoryOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public class Property : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
-
+
internal Property(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
-
+
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
-
+
~Property() {
Dispose();
}
-
+
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
global::System.GC.SuppressFinalize(this);
}
}
-
+
public Property() : this(NDalicPINVOKE.new_RenderTask_Property(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
-
+
public static readonly int VIEWPORT_POSITION = NDalicPINVOKE.RenderTask_Property_VIEWPORT_POSITION_get();
public static readonly int VIEWPORT_SIZE = NDalicPINVOKE.RenderTask_Property_VIEWPORT_SIZE_get();
public static readonly int CLEAR_COLOR = NDalicPINVOKE.RenderTask_Property_CLEAR_COLOR_get();
public static readonly int REQUIRES_SYNC = NDalicPINVOKE.RenderTask_Property_REQUIRES_SYNC_get();
-
+
}
public static SWIGTYPE_p_f_r_Dali__Vector2__bool DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION {
SWIGTYPE_p_f_r_Dali__Vector2__bool ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_f_r_Dali__Vector2__bool(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
- }
+ }
}
public static SWIGTYPE_p_f_r_Dali__Vector2__bool FULLSCREEN_FRAMEBUFFER_FUNCTION {
SWIGTYPE_p_f_r_Dali__Vector2__bool ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_f_r_Dali__Vector2__bool(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
- }
+ }
}
public static bool DEFAULT_EXCLUSIVE {
bool ret = NDalicPINVOKE.RenderTask_DEFAULT_EXCLUSIVE_get();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
- }
+ }
}
public static bool DEFAULT_INPUT_ENABLED {
bool ret = NDalicPINVOKE.RenderTask_DEFAULT_INPUT_ENABLED_get();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
- }
+ }
}
public static Vector4 DEFAULT_CLEAR_COLOR {
Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
- }
+ }
}
public static bool DEFAULT_CLEAR_ENABLED {
bool ret = NDalicPINVOKE.RenderTask_DEFAULT_CLEAR_ENABLED_get();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
- }
+ }
}
public static bool DEFAULT_CULL_MODE {
bool ret = NDalicPINVOKE.RenderTask_DEFAULT_CULL_MODE_get();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
- }
+ }
}
public static uint DEFAULT_REFRESH_RATE {
uint ret = NDalicPINVOKE.RenderTask_DEFAULT_REFRESH_RATE_get();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
- }
+ }
}
public RenderTask() : this(NDalicPINVOKE.new_RenderTask__SWIG_0(), true) {
return ret;
}
- public void SetSourceActor(Actor actor) {
- NDalicPINVOKE.RenderTask_SetSourceActor(swigCPtr, Actor.getCPtr(actor));
+ public void SetSourceView(View view) {
+ NDalicPINVOKE.RenderTask_SetSourceActor(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetSourceActor() {
- Actor ret = new Actor(NDalicPINVOKE.RenderTask_GetSourceActor(swigCPtr), true);
+ public View GetSourceView() {
+ View ret = new View(NDalicPINVOKE.RenderTask_GetSourceActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public void SetCameraActor(CameraActor cameraActor) {
- NDalicPINVOKE.RenderTask_SetCameraActor(swigCPtr, CameraActor.getCPtr(cameraActor));
+ public void SetCamera(Camera camera) {
+ NDalicPINVOKE.RenderTask_SetCameraActor(swigCPtr, Camera.getCPtr(camera));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public CameraActor GetCameraActor() {
- CameraActor ret = new CameraActor(NDalicPINVOKE.RenderTask_GetCameraActor(swigCPtr), true);
+ public Camera GetCamera() {
+ Camera ret = new Camera(NDalicPINVOKE.RenderTask_GetCameraActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public void SetScreenToFrameBufferMappingActor(Actor mappingActor) {
- NDalicPINVOKE.RenderTask_SetScreenToFrameBufferMappingActor(swigCPtr, Actor.getCPtr(mappingActor));
+ public void SetScreenToFrameBufferMappingView(View mappingView) {
+ NDalicPINVOKE.RenderTask_SetScreenToFrameBufferMappingActor(swigCPtr, View.getCPtr(mappingView));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetScreenToFrameBufferMappingActor() {
- Actor ret = new Actor(NDalicPINVOKE.RenderTask_GetScreenToFrameBufferMappingActor(swigCPtr), true);
+ public View GetScreenToFrameBufferMappingView() {
+ View ret = new View(NDalicPINVOKE.RenderTask_GetScreenToFrameBufferMappingActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public bool ViewportToLocal(Actor actor, float viewportX, float viewportY, out float localX, out float localY) {
- bool ret = NDalicPINVOKE.RenderTask_ViewportToLocal(swigCPtr, Actor.getCPtr(actor), viewportX, viewportY, out localX, out localY);
+ public bool ViewportToLocal(View view, float viewportX, float viewportY, out float localX, out float localY) {
+ bool ret = NDalicPINVOKE.RenderTask_ViewportToLocal(swigCPtr, View.getCPtr(view), viewportX, viewportY, out localX, out localY);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
namespace Dali {
-public class Renderer : Handle {
+public class Renderer : Animatable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal Renderer(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Renderer_SWIGUpcast(cPtr), cMemoryOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
get
{
int temp = 0;
- GetProperty( Renderer.Property.DEPTH_INDEX).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.DEPTH_INDEX).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.DEPTH_INDEX, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.DEPTH_INDEX, new Dali.Property.Value( value ) );
}
}
public int FaceCullingMode
get
{
int temp = 0;
- GetProperty( Renderer.Property.FACE_CULLING_MODE).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.FACE_CULLING_MODE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.FACE_CULLING_MODE, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.FACE_CULLING_MODE, new Dali.Property.Value( value ) );
}
}
public int BlendMode
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_MODE).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.BLEND_MODE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_MODE, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.BLEND_MODE, new Dali.Property.Value( value ) );
}
}
public int BlendEquationRgb
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_EQUATION_RGB).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.BLEND_EQUATION_RGB).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_EQUATION_RGB, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.BLEND_EQUATION_RGB, new Dali.Property.Value( value ) );
}
}
public int BlendEquationAlpha
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_EQUATION_ALPHA).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.BLEND_EQUATION_ALPHA).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_EQUATION_ALPHA, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.BLEND_EQUATION_ALPHA, new Dali.Property.Value( value ) );
}
}
public int BlendFactorSrcRgb
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_FACTOR_SRC_RGB).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.BLEND_FACTOR_SRC_RGB).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_FACTOR_SRC_RGB, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.BLEND_FACTOR_SRC_RGB, new Dali.Property.Value( value ) );
}
}
public int BlendFactorDestRgb
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_FACTOR_DEST_RGB).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.BLEND_FACTOR_DEST_RGB).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_FACTOR_DEST_RGB, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.BLEND_FACTOR_DEST_RGB, new Dali.Property.Value( value ) );
}
}
public int BlendFactorSrcAlpha
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_FACTOR_SRC_ALPHA).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.BLEND_FACTOR_SRC_ALPHA).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_FACTOR_SRC_ALPHA, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.BLEND_FACTOR_SRC_ALPHA, new Dali.Property.Value( value ) );
}
}
public int BlendFactorDestAlpha
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_FACTOR_DEST_ALPHA).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.BLEND_FACTOR_DEST_ALPHA).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_FACTOR_DEST_ALPHA, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.BLEND_FACTOR_DEST_ALPHA, new Dali.Property.Value( value ) );
}
}
public Vector4 BlendColor
get
{
Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
- GetProperty( Renderer.Property.BLEND_COLOR).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.BLEND_COLOR).Get( temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_COLOR, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.BLEND_COLOR, new Dali.Property.Value( value ) );
}
}
public bool BlendPreMultipliedAlpha
get
{
bool temp = false;
- GetProperty( Renderer.Property.BLEND_PRE_MULTIPLIED_ALPHA).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.BLEND_PRE_MULTIPLIED_ALPHA).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_PRE_MULTIPLIED_ALPHA, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.BLEND_PRE_MULTIPLIED_ALPHA, new Dali.Property.Value( value ) );
}
}
public int IndexRangeFirst
get
{
int temp = 0;
- GetProperty( Renderer.Property.INDEX_RANGE_FIRST).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.INDEX_RANGE_FIRST).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.INDEX_RANGE_FIRST, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.INDEX_RANGE_FIRST, new Dali.Property.Value( value ) );
}
}
public int IndexRangeCount
get
{
int temp = 0;
- GetProperty( Renderer.Property.INDEX_RANGE_COUNT).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.INDEX_RANGE_COUNT).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.INDEX_RANGE_COUNT, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.INDEX_RANGE_COUNT, new Dali.Property.Value( value ) );
}
}
public int DepthWriteMode
get
{
int temp = 0;
- GetProperty( Renderer.Property.DEPTH_WRITE_MODE).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.DEPTH_WRITE_MODE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.DEPTH_WRITE_MODE, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.DEPTH_WRITE_MODE, new Dali.Property.Value( value ) );
}
}
public int DepthFunction
get
{
int temp = 0;
- GetProperty( Renderer.Property.DEPTH_FUNCTION).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.DEPTH_FUNCTION).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.DEPTH_FUNCTION, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.DEPTH_FUNCTION, new Dali.Property.Value( value ) );
}
}
public int DepthTestMode
get
{
int temp = 0;
- GetProperty( Renderer.Property.DEPTH_TEST_MODE).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.DEPTH_TEST_MODE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.DEPTH_TEST_MODE, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.DEPTH_TEST_MODE, new Dali.Property.Value( value ) );
}
}
public int RenderMode
get
{
int temp = 0;
- GetProperty( Renderer.Property.RENDER_MODE).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.RENDER_MODE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.RENDER_MODE, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.RENDER_MODE, new Dali.Property.Value( value ) );
}
}
public int StencilFunction
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_FUNCTION).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.STENCIL_FUNCTION).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_FUNCTION, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.STENCIL_FUNCTION, new Dali.Property.Value( value ) );
}
}
public int StencilFunctionMask
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_FUNCTION_MASK).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.STENCIL_FUNCTION_MASK).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_FUNCTION_MASK, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.STENCIL_FUNCTION_MASK, new Dali.Property.Value( value ) );
}
}
public int StencilFunctionReference
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_FUNCTION_REFERENCE).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.STENCIL_FUNCTION_REFERENCE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_FUNCTION_REFERENCE, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.STENCIL_FUNCTION_REFERENCE, new Dali.Property.Value( value ) );
}
}
public int StencilMask
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_MASK).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.STENCIL_MASK).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_MASK, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.STENCIL_MASK, new Dali.Property.Value( value ) );
}
}
public int StencilOperationOnFail
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_OPERATION_ON_FAIL).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_FAIL).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_OPERATION_ON_FAIL, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_FAIL, new Dali.Property.Value( value ) );
}
}
public int StencilOperationOnZFail
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_OPERATION_ON_Z_FAIL).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_Z_FAIL).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_OPERATION_ON_Z_FAIL, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_Z_FAIL, new Dali.Property.Value( value ) );
}
}
public int StencilOperationOnZPass
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_OPERATION_ON_Z_PASS).Get( ref temp );
+ Dali.Object.GetProperty( swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_Z_PASS).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_OPERATION_ON_Z_PASS, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_Z_PASS, new Dali.Property.Value( value ) );
}
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public void SetScrollPropertySource(Handle handle, int propertyScrollPosition, int propertyMinScrollPosition, int propertyMaxScrollPosition, int propertyScrollContentSize) {
- NDalicPINVOKE.ScrollBar_SetScrollPropertySource(swigCPtr, Handle.getCPtr(handle), propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
+ public void SetScrollPropertySource(Animatable handle, int propertyScrollPosition, int propertyMinScrollPosition, int propertyMaxScrollPosition, int propertyScrollContentSize) {
+ NDalicPINVOKE.ScrollBar_SetScrollPropertySource(swigCPtr, Animatable.getCPtr(handle), propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetScrollIndicator(Actor indicator) {
- NDalicPINVOKE.ScrollBar_SetScrollIndicator(swigCPtr, Actor.getCPtr(indicator));
+ public void SetScrollIndicator(View indicator) {
+ NDalicPINVOKE.ScrollBar_SetScrollIndicator(swigCPtr, View.getCPtr(indicator));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetScrollIndicator() {
- Actor ret = new Actor(NDalicPINVOKE.ScrollBar_GetScrollIndicator(swigCPtr), true);
+ public View GetScrollIndicator() {
+ View ret = new View(NDalicPINVOKE.ScrollBar_GetScrollIndicator(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetActorAutoSnap(bool enable) {
+ public void SetViewAutoSnap(bool enable) {
NDalicPINVOKE.ScrollView_SetActorAutoSnap(swigCPtr, enable);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void ScrollTo(Actor actor) {
- NDalicPINVOKE.ScrollView_ScrollTo__SWIG_8(swigCPtr, Actor.getCPtr(actor));
+ public void ScrollTo(View view) {
+ NDalicPINVOKE.ScrollView_ScrollTo__SWIG_8(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void ScrollTo(Actor actor, float duration) {
- NDalicPINVOKE.ScrollView_ScrollTo__SWIG_9(swigCPtr, Actor.getCPtr(actor), duration);
+ public void ScrollTo(View view, float duration) {
+ NDalicPINVOKE.ScrollView_ScrollTo__SWIG_9(swigCPtr, View.getCPtr(view), duration);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void BindActor(Actor child) {
- NDalicPINVOKE.ScrollView_BindActor(swigCPtr, Actor.getCPtr(child));
+ public void BindView(View child) {
+ NDalicPINVOKE.ScrollView_BindActor(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void UnbindActor(Actor child) {
- NDalicPINVOKE.ScrollView_UnbindActor(swigCPtr, Actor.getCPtr(child));
+ public void UnbindView(View child) {
+ NDalicPINVOKE.ScrollView_UnbindActor(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public void ApplyToPage(Actor page, uint pageOrder) {
- NDalicPINVOKE.ScrollViewPagePathEffect_ApplyToPage(swigCPtr, Actor.getCPtr(page), pageOrder);
+ public void ApplyToPage(View page, uint pageOrder) {
+ NDalicPINVOKE.ScrollViewPagePathEffect_ApplyToPage(swigCPtr, View.getCPtr(page), pageOrder);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
namespace Dali {
-public class Shader : Handle {
+public class Shader : Animatable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal Shader(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Shader_SWIGUpcast(cPtr), cMemoryOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public class Hint : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
-
+
internal Hint(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
-
+
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Hint obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
-
+
~Hint() {
Dispose();
}
-
+
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
global::System.GC.SuppressFinalize(this);
}
}
-
+
public Hint() : this(NDalicPINVOKE.new_Shader_Hint(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
-
+
public enum Value {
NONE = 0x00,
OUTPUT_IS_TRANSPARENT = 0x01,
MODIFIES_GEOMETRY = 0x02
}
-
+
}
public class Property : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
-
+
internal Property(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
-
+
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
global::System.GC.SuppressFinalize(this);
}
}
-
+
public Property() : this(NDalicPINVOKE.new_Shader_Property(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
-
+
public static readonly int PROGRAM = NDalicPINVOKE.Shader_Property_PROGRAM_get();
-
+
}
public Shader (string vertexShader, string fragmentShader, Shader.Hint.Value hints) : this (NDalicPINVOKE.Shader_New__SWIG_0(vertexShader, fragmentShader, (int)hints), true) {
get
{
Dali.Property.Map temp = new Dali.Property.Map();
- GetProperty( Shader.Property.PROGRAM).Get( temp );
+ Dali.Object.GetProperty( swigCPtr, Shader.Property.PROGRAM).Get( temp );
return temp;
}
set
{
- SetProperty( Shader.Property.PROGRAM, new Dali.Property.Value( value ) );
+ Dali.Object.SetProperty( swigCPtr, Shader.Property.PROGRAM, new Dali.Property.Value( value ) );
}
}
-
}
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
+++ /dev/null
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.10
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Dali {
-
-using System;
-using System.Runtime.InteropServices;
-
-
-public class Stage : BaseHandle {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
- internal Stage(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Stage_SWIGUpcast(cPtr), cMemoryOwn) {
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
-
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Stage obj) {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
-
- ~Stage() {
- DisposeQueue.Instance.Add(this);
- }
-
- public override void Dispose() {
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_Stage(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- base.Dispose();
- }
- }
-
-
-
-
- /**
- * @brief Event arguments that passed via Touch signal
- *
- */
- public class TouchEventArgs : EventArgs
- {
- private Touch _touch;
-
- /**
- * @brief Touch - contains the information of touch points
- *
- */
- public Touch Touch
- {
- get
- {
- return _touch;
- }
- set
- {
- _touch = value;
- }
- }
- }
-
- private event EventHandler<TouchEventArgs> _stageTouchHandler;
- private EventCallbackDelegateType1<IntPtr> _stageTouchCallbackDelegate;
-
- /**
- * @brief Event for TouchEvent signal which can be used to subscribe/unsubscribe the event handler
- * TouchEvent signal is emitted when the screen is touched and when the touch ends
- * (i.e. the down & up touch events only).
- *
- */
- public event EventHandler<TouchEventArgs> Touch
- {
- add
- {
- lock(this)
- {
- _stageTouchHandler += value;
- _stageTouchCallbackDelegate = OnStageTouch;
- this.TouchSignal().Connect(_stageTouchCallbackDelegate);
- }
- }
- remove
- {
- lock(this)
- {
- if (_stageTouchHandler != null)
- {
- this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
- }
- _stageTouchHandler -= value;
- }
- }
- }
-
- private void OnStageTouch(IntPtr data)
- {
- TouchEventArgs e = new TouchEventArgs();
-
- if( data != null )
- {
- e.Touch = Dali.Touch.GetTouchFromPtr( data );
- }
-
- if (_stageTouchHandler != null)
- {
- _stageTouchHandler(this, e);
- }
- }
-
- /**
- * @brief Wheel arguments that passed via Wheel signal
- *
- */
- public class WheelEventArgs : EventArgs
- {
- private Wheel _wheel;
-
- /**
- * @brief Wheel - store a wheel rolling type MOUSE_WHEEL or CUSTOM_WHEEL
- *
- */
- public Wheel Wheel
- {
- get
- {
- return _wheel;
- }
- set
- {
- _wheel = value;
- }
- }
- }
-
- private event EventHandler<WheelEventArgs> _stageWheelHandler;
- private EventCallbackDelegateType1<IntPtr> _stageWheelCallbackDelegate;
-
- /**
- * @brief Event for Wheel signal which can be used to subscribe/unsubscribe the event handler
- * Wheel signal is emitted is emitted when wheel event is received.
- *
- */
- public event EventHandler<WheelEventArgs> Wheel
- {
- add
- {
- lock(this)
- {
- _stageWheelHandler += value;
- _stageWheelCallbackDelegate = OnStageWheel;
- this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
- }
- }
- remove
- {
- lock(this)
- {
- if (_stageWheelHandler != null)
- {
- this.WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
- }
- _stageWheelHandler -= value;
- }
- }
- }
-
- private void OnStageWheel(IntPtr data)
- {
- WheelEventArgs e = new WheelEventArgs();
-
- if( data != null )
- {
- e.Wheel = Dali.Wheel.GetWheelFromPtr( data );
- }
-
- if (_stageWheelHandler != null)
- {
- _stageWheelHandler(this, e);
- }
- }
-
- /**
- * @brief Event arguments that passed via Key signal
- *
- */
- public class KeyEventArgs : EventArgs
- {
- private Key _key;
-
- /**
- * @brief Key - is the keyevent sent to Stage.
- *
- */
- public Key Key
- {
- get
- {
- return _key;
- }
- set
- {
- _key = value;
- }
- }
- }
-
- private event EventHandler<KeyEventArgs> _stageKeyHandler;
- private EventCallbackDelegateType1<IntPtr> _stageKeyCallbackDelegate;
-
- /**
- * @brief Event for Key signal which can be used to subscribe/unsubscribe the event handler
- * Key signal is emitted is emitted when key event is received.
- *
- */
- public event EventHandler<KeyEventArgs> Key
- {
- add
- {
- lock(this)
- {
- _stageKeyHandler += value;
- _stageKeyCallbackDelegate = OnStageKey;
- this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
- }
- }
- remove
- {
- lock(this)
- {
- if (_stageKeyHandler != null)
- {
- this.KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
- }
- _stageKeyHandler -= value;
- }
- }
- }
-
- // Callback for Stage KeyEventsignal
- private void OnStageKey(IntPtr data)
- {
- KeyEventArgs e = new KeyEventArgs();
-
- if( data != null )
- {
- e.Key = Dali.Key.GetKeyFromPtr( data );
- }
-
- if (_stageKeyHandler != null)
- {
- //here we send all data to user event handlers
- _stageKeyHandler(this, e);
- }
- }
-
-
- private event EventHandler _stageEventProcessingFinishedEventHandler;
- private EventCallbackDelegateType0 _stageEventProcessingFinishedEventCallbackDelegate;
-
- /**
- * @brief Event for EventProcessingFinished signal which can be used to subscribe/unsubscribe the event handler
- * provided by the user. EventProcessingFinished signal is emitted just after the event processing is finished.
- *
- */
- public event EventHandler EventProcessingFinished
- {
- add
- {
- lock(this)
- {
- _stageEventProcessingFinishedEventHandler += value;
- _stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
- this.EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
- }
- }
- remove
- {
- lock(this)
- {
- if (_stageEventProcessingFinishedEventHandler != null)
- {
- this.EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
- }
- _stageEventProcessingFinishedEventHandler -= value;
- }
- }
- }
-
- // Callback for Stage EventProcessingFinishedSignal
- private void OnEventProcessingFinished()
- {
- if (_stageEventProcessingFinishedEventHandler != null)
- {
- _stageEventProcessingFinishedEventHandler(this, null);
- }
- }
-
-
- private EventHandler _stageContextLostEventHandler;
- private EventCallbackDelegateType0 _stageContextLostEventCallbackDelegate;
-
- /**
- * @brief Event for ContextLost signal which can be used to subscribe/unsubscribe the event handler
- * ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).
- *
- */
- public event EventHandler ContextLost
- {
- add
- {
- lock(this)
- {
- _stageContextLostEventHandler += value;
- _stageContextLostEventCallbackDelegate = OnContextLost;
- this.ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
- }
- }
- remove
- {
- lock(this)
- {
- if (_stageContextLostEventHandler != null)
- {
- this.ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
- }
-
- _stageContextLostEventHandler -= value;
- }
- }
- }
-
- // Callback for Stage ContextLostSignal
- private void OnContextLost()
- {
- if (_stageContextLostEventHandler != null)
- {
- _stageContextLostEventHandler(this, null);
- }
- }
-
-
- private EventHandler _stageContextRegainedEventHandler;
- private EventCallbackDelegateType0 _stageContextRegainedEventCallbackDelegate;
-
- /**
- * @brief Event for ContextRegained signal which can be used to subscribe/unsubscribe the event handler
- * provided by the user. ContextRegained signal is emitted when the GL context is regained (Platform specific
- * behaviour).
- *
- */
- public event EventHandler ContextRegained
- {
- add
- {
- lock(this)
- {
- _stageContextRegainedEventHandler += value;
- _stageContextRegainedEventCallbackDelegate = OnContextRegained;
- this.ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
- }
- }
- remove
- {
- lock(this)
- {
- if (_stageContextRegainedEventHandler != null)
- {
- this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
- }
-
- _stageContextRegainedEventHandler -= value;
- }
- }
- }
-
- // Callback for Stage ContextRegainedSignal
- private void OnContextRegained()
- {
- if (_stageContextRegainedEventHandler != null)
- {
- _stageContextRegainedEventHandler(this, null);
- }
- }
-
-
- private EventHandler _stageSceneCreatedEventHandler;
- private EventCallbackDelegateType0 _stageSceneCreatedEventCallbackDelegate;
-
- /**
- * @brief Event for SceneCreated signal which can be used to subscribe/unsubscribe the event handler
- * SceneCreated signal is emitted after the initial scene is created.
- *
- */
- public event EventHandler SceneCreated
- {
- add
- {
- lock(this)
- {
- _stageSceneCreatedEventHandler += value;
- _stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
- this.SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
- }
- }
- remove
- {
- lock(this)
- {
- if (_stageSceneCreatedEventHandler != null)
- {
- this.SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
- }
-
- _stageSceneCreatedEventHandler -= value;
- }
- }
- }
-
- // Callback for Stage SceneCreatedSignal
- private void OnSceneCreated()
- {
- if (_stageSceneCreatedEventHandler != null)
- {
- _stageSceneCreatedEventHandler(this, null);
- }
- }
-
-
- public Vector2 Size
- {
- get
- {
- Vector2 ret = GetSize();
- return ret;
- }
- }
-
- public Vector4 BackgroundColor
- {
- set
- {
- SetBackgroundColor(value);
- }
- get
- {
- Vector4 ret = GetBackgroundColor();
- return ret;
- }
- }
-
- private static readonly Stage instance = Stage.GetCurrent();
-
- public static Stage Instance
- {
- get
- {
- return instance;
- }
- }
-
- public Layer GetDefaultLayer()
- {
- return this.GetRootLayer();
- }
-
- public void AddLayer(Layer layer)
- {
- this.Add( (Actor)layer );
- }
-
- public void RemoveLayer(Layer layer)
- {
- this.Remove( (Actor)layer );
- }
-
-
-
- public static Vector4 DEFAULT_BACKGROUND_COLOR {
- get {
- global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEFAULT_BACKGROUND_COLOR_get();
- Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
- }
-
- public static Vector4 DEBUG_BACKGROUND_COLOR {
- get {
- global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEBUG_BACKGROUND_COLOR_get();
- Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
- }
-
- public Stage() : this(NDalicPINVOKE.new_Stage__SWIG_0(), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public static Stage GetCurrent() {
- Stage ret = new Stage(NDalicPINVOKE.Stage_GetCurrent(), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public static bool IsInstalled() {
- bool ret = NDalicPINVOKE.Stage_IsInstalled();
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Stage(Stage handle) : this(NDalicPINVOKE.new_Stage__SWIG_1(Stage.getCPtr(handle)), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Stage Assign(Stage rhs) {
- Stage ret = new Stage(NDalicPINVOKE.Stage_Assign(swigCPtr, Stage.getCPtr(rhs)), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void Add(Actor actor) {
- NDalicPINVOKE.Stage_Add(swigCPtr, Actor.getCPtr(actor));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void Remove(Actor actor) {
- NDalicPINVOKE.Stage_Remove(swigCPtr, Actor.getCPtr(actor));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector2 GetSize() {
- Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public RenderTaskList GetRenderTaskList() {
- RenderTaskList ret = new RenderTaskList(NDalicPINVOKE.Stage_GetRenderTaskList(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public uint GetLayerCount() {
- uint ret = NDalicPINVOKE.Stage_GetLayerCount(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Layer GetLayer(uint depth) {
- Layer ret = new Layer(NDalicPINVOKE.Stage_GetLayer(swigCPtr, depth), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Layer GetRootLayer() {
- Layer ret = new Layer(NDalicPINVOKE.Stage_GetRootLayer(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetBackgroundColor(Vector4 color) {
- NDalicPINVOKE.Stage_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector4 GetBackgroundColor() {
- Vector4 ret = new Vector4(NDalicPINVOKE.Stage_GetBackgroundColor(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public Vector2 GetDpi() {
- Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetDpi(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public ObjectRegistry GetObjectRegistry() {
- ObjectRegistry ret = new ObjectRegistry(NDalicPINVOKE.Stage_GetObjectRegistry(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void KeepRendering(float durationSeconds) {
- NDalicPINVOKE.Stage_KeepRendering(swigCPtr, durationSeconds);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public KeyEventSignal KeyEventSignal() {
- KeyEventSignal ret = new KeyEventSignal(NDalicPINVOKE.Stage_KeyEventSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public VoidSignal EventProcessingFinishedSignal() {
- VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_EventProcessingFinishedSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public TouchSignal TouchSignal() {
- TouchSignal ret = new TouchSignal(NDalicPINVOKE.Stage_TouchSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public StageWheelSignal WheelEventSignal() {
- StageWheelSignal ret = new StageWheelSignal(NDalicPINVOKE.Stage_WheelEventSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public VoidSignal ContextLostSignal() {
- VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextLostSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public VoidSignal ContextRegainedSignal() {
- VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextRegainedSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public VoidSignal SceneCreatedSignal() {
- VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_SceneCreatedSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
-}
-
-}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public bool AddChild(Actor child, TableView.CellPosition position) {
- bool ret = NDalicPINVOKE.TableView_AddChild(swigCPtr, Actor.getCPtr(child), TableView.CellPosition.getCPtr(position));
+ public bool AddChild(View child, TableView.CellPosition position) {
+ bool ret = NDalicPINVOKE.TableView_AddChild(swigCPtr, View.getCPtr(child), TableView.CellPosition.getCPtr(position));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor GetChildAt(TableView.CellPosition position) {
- Actor ret = new Actor(NDalicPINVOKE.TableView_GetChildAt(swigCPtr, TableView.CellPosition.getCPtr(position)), true);
+ public View GetChildAt(TableView.CellPosition position) {
+ View ret = new View(NDalicPINVOKE.TableView_GetChildAt(swigCPtr, TableView.CellPosition.getCPtr(position)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor RemoveChildAt(TableView.CellPosition position) {
- Actor ret = new Actor(NDalicPINVOKE.TableView_RemoveChildAt(swigCPtr, TableView.CellPosition.getCPtr(position)), true);
+ public View RemoveChildAt(TableView.CellPosition position) {
+ View ret = new View(NDalicPINVOKE.TableView_RemoveChildAt(swigCPtr, TableView.CellPosition.getCPtr(position)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public bool FindChildPosition(Actor child, TableView.CellPosition position) {
- bool ret = NDalicPINVOKE.TableView_FindChildPosition(swigCPtr, Actor.getCPtr(child), TableView.CellPosition.getCPtr(position));
+ public bool FindChildPosition(View child, TableView.CellPosition position) {
+ bool ret = NDalicPINVOKE.TableView_FindChildPosition(swigCPtr, View.getCPtr(child), TableView.CellPosition.getCPtr(position));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void DeleteRow(uint rowIndex, ActorContainer removed) {
- NDalicPINVOKE.TableView_DeleteRow__SWIG_1(swigCPtr, rowIndex, ActorContainer.getCPtr(removed));
+ public void DeleteRow(uint rowIndex, ViewContainer removed) {
+ NDalicPINVOKE.TableView_DeleteRow__SWIG_1(swigCPtr, rowIndex, ViewContainer.getCPtr(removed));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void DeleteColumn(uint columnIndex, ActorContainer removed) {
- NDalicPINVOKE.TableView_DeleteColumn__SWIG_1(swigCPtr, columnIndex, ActorContainer.getCPtr(removed));
+ public void DeleteColumn(uint columnIndex, ViewContainer removed) {
+ NDalicPINVOKE.TableView_DeleteColumn__SWIG_1(swigCPtr, columnIndex, ViewContainer.getCPtr(removed));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void Resize(uint rows, uint columns, ActorContainer removed) {
- NDalicPINVOKE.TableView_Resize__SWIG_1(swigCPtr, rows, columns, ActorContainer.getCPtr(removed));
+ public void Resize(uint rows, uint columns, ViewContainer removed) {
+ NDalicPINVOKE.TableView_Resize__SWIG_1(swigCPtr, rows, columns, ViewContainer.getCPtr(removed));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, TapGesture arg2) {
- NDalicPINVOKE.TapGestureDetectedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), TapGesture.getCPtr(arg2));
+ public void Emit(View arg1, TapGesture arg2) {
+ NDalicPINVOKE.TapGestureDetectedSignal_Emit(swigCPtr, View.getCPtr(arg1), TapGesture.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public class DetectedEventArgs : EventArgs
{
- private Actor _actor;
+ private View _view;
private TapGesture _tapGesture;
- public Actor Actor
+ public View View
{
get
{
- return _actor;
+ return _view;
}
set
{
- _actor = value;
+ _view = value;
}
}
DetectedEventArgs e = new DetectedEventArgs();
// Populate all members of "e" (DetectedEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
+ e.View = View.GetViewFromPtr(actor);
e.TapGesture = Dali.TapGesture.GetTapGestureFromPtr(tapGesture);
if (_tapGestureEventHandler != null)
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public Actor GetHitActor(uint point) {
- Actor ret = new Actor(NDalicPINVOKE.Touch_GetHitActor(swigCPtr, point), true);
+ public View GetHitView(uint point) {
+ View ret = new View(NDalicPINVOKE.Touch_GetHitActor(swigCPtr, point), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
namespace Dali {
-public class ActorTouchDataSignal : global::System.IDisposable {
+internal class TouchDataSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal ActorTouchDataSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ internal TouchDataSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ActorTouchDataSignal obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(TouchDataSignal obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~ActorTouchDataSignal() {
+ ~TouchDataSignal() {
DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public bool Emit(Actor arg1, Touch arg2) {
- bool ret = NDalicPINVOKE.ActorTouchDataSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Touch.getCPtr(arg2));
+ public bool Emit(View arg1, Touch arg2) {
+ bool ret = NDalicPINVOKE.ActorTouchDataSignal_Emit(swigCPtr, View.getCPtr(arg1), Touch.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public ActorTouchDataSignal() : this(NDalicPINVOKE.new_ActorTouchDataSignal(), true) {
+ public TouchDataSignal() : this(NDalicPINVOKE.new_ActorTouchDataSignal(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public Actor hitActor {
+ public View hitView {
set {
- NDalicPINVOKE.TouchPoint_hitActor_set(swigCPtr, Actor.getCPtr(value));
+ NDalicPINVOKE.TouchPoint_hitActor_set(swigCPtr, View.getCPtr(value));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get {
global::System.IntPtr cPtr = NDalicPINVOKE.TouchPoint_hitActor_get(swigCPtr);
- Actor ret = (cPtr == global::System.IntPtr.Zero) ? null : new Actor(cPtr, false);
+ View ret = (cPtr == global::System.IntPtr.Zero) ? null : new View(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
*
*/
-namespace Dali {
-
+namespace Dali
+{
using System;
using System.Runtime.InteropServices;
+ public class View : Animatable
+ {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-public class View : CustomActor {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
- internal View(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.View_SWIGUpcast(cPtr), cMemoryOwn) {
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-
- // Register this instance of view in the view registry.
- ViewRegistry.RegisterView(this);
-
- // By default, we do not want the position to use the anchor point
- this.PositionUsesAnchorPoint = false;
- }
+ internal View(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.View_SWIGUpcast(cPtr), cMemoryOwn)
+ {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(View obj) {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
+ // Register this instance of view in the view registry.
+ ViewRegistry.RegisterView(this);
- ~View() {
- DisposeQueue.Instance.Add(this);
+ // By default, we do not want the position to use the anchor point
+ this.PositionUsesAnchorPoint = false;
+ }
- // Unregister this instance of view from the view registry.
- ViewRegistry.UnregisterView(this);
- }
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(View obj)
+ {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
- public override void Dispose() {
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
+ ~View()
+ {
+ DisposeQueue.Instance.Add(this);
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_View(swigCPtr);
+ // Unregister this instance of view from the view registry.
+ ViewRegistry.UnregisterView(this);
}
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- base.Dispose();
- }
- }
-
- /**
- * @brief Event arguments that passed via KeyInputFocusGained signal
- *
- */
- public class KeyInputFocusGainedEventArgs : EventArgs
- {
- private View _view;
-
- /**
- * @brief View - is the view that gets Key Input Focus
- *
- */
- public View View
- {
- get
- {
- return _view;
- }
- set
- {
- _view = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via KeyInputFocusLost signal
- *
- */
- public class KeyInputFocusLostEventArgs : EventArgs
- {
- private View _view;
-
- /**
- * @brief View - is the view that loses Key Input Focus
- *
- */
- public View View
- {
- get
- {
- return _view;
- }
- set
- {
- _view = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via Key signal
- *
- */
- public class KeyEventArgs : EventArgs
- {
- private View _view;
- private Key _key;
-
- /**
- * @brief View - is the view that recieves the key.
- *
- */
- public View View
- {
- get
- {
- return _view;
- }
- set
- {
- _view = value;
- }
- }
-
- /**
- * @brief Key - is the key sent to the View.
- *
- */
- public Key Key
- {
- get
- {
- return _key;
- }
- set
- {
- _key = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via OnRelayout signal
- *
- */
- public class OnRelayoutEventArgs : EventArgs
- {
- private View _view;
-
- /**
- * @brief View - is the view that is being resized upon relayout
- *
- */
- public View View
- {
- get
- {
- return _view;
- }
- set
- {
- _view = value;
- }
- }
- }
-
-
- /**
- * @brief Event arguments that passed via Touch signal
- *
- */
- public class TouchEventArgs : EventArgs
- {
- private View _view;
- private Touch _touch;
-
- /**
- * @brief View - is the view that is being touched
- *
- */
- public View View
- {
- get
- {
- return _view;
- }
- set
- {
- _view = value;
- }
- }
- /**
- * @brief Touch - contains the information of touch points
- *
- */
- public Touch Touch
- {
- get
- {
- return _touch;
- }
- set
- {
- _touch = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via Hover signal
- *
- */
- public class HoverEventArgs : EventArgs
- {
- private View _view;
- private Hover _hover;
-
- /**
- * @brief View - is the view that is being hovered
- *
- */
- public View View
- {
- get
- {
- return _view;
- }
- set
- {
- _view = value;
- }
- }
+ public virtual void Dispose()
+ {
+ if (!Window.IsInstalled())
+ {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
+ lock (this)
+ {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero)
+ {
+ if (swigCMemOwn)
+ {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_View(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
- /**
- * @brief Hover - contains touch points that represent the points
- * that are currently being hovered or the points where a hover has stopped
- *
- */
- public Hover Hover
- {
- get
- {
- return _hover;
- }
- set
- {
- _hover = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via Wheel signal
- *
- */
- public class WheelEventArgs : EventArgs
- {
- private View _view;
- private Wheel _wheel;
-
- /**
- * @brief View - is the view that is being wheeled
- *
- */
- public View View
- {
- get
- {
- return _view;
- }
- set
- {
- _view = value;
- }
- }
+ /**
+ * @brief Event arguments that passed via KeyInputFocusGained signal
+ *
+ */
+ public class KeyInputFocusGainedEventArgs : EventArgs
+ {
+ private View _view;
+
+ /**
+ * @brief View - is the view that gets Key Input Focus
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+ }
- /**
- * @brief Wheel - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
- *
- */
- public Wheel Wheel
- {
- get
- {
- return _wheel;
- }
- set
- {
- _wheel = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via OnStage signal
- *
- */
- public class OnStageEventArgs : EventArgs
- {
- private View _view;
-
- /**
- * @brief View - is the view that is being connected to the stage
- *
- */
- public View View
- {
- get
- {
- return _view;
- }
- set
- {
- _view = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via OffStage signal
- *
- */
- public class OffStageEventArgs : EventArgs
- {
- private View _view;
-
- /**
- * @brief View - is the view that is being disconnected from the stage
- *
- */
- public View View
- {
- get
- {
- return _view;
- }
- set
- {
- _view = value;
- }
- }
- }
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr control);
- private DaliEventHandler<object,KeyInputFocusGainedEventArgs> _KeyInputFocusGainedEventHandler;
- private KeyInputFocusGainedCallbackDelegate _KeyInputFocusGainedCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void KeyInputFocusLostCallbackDelegate(IntPtr control);
- private DaliEventHandler<object,KeyInputFocusLostEventArgs> _KeyInputFocusLostEventHandler;
- private KeyInputFocusLostCallbackDelegate _KeyInputFocusLostCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate bool KeyCallbackDelegate(IntPtr control, IntPtr key);
- private DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> _KeyHandler;
- private KeyCallbackDelegate _KeyCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void OnRelayoutEventCallbackDelegate(IntPtr control);
- private DaliEventHandler<object,OnRelayoutEventArgs> _viewOnRelayoutEventHandler;
- private OnRelayoutEventCallbackDelegate _viewOnRelayoutEventCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate bool TouchCallbackDelegate(IntPtr view, IntPtr touch);
- private DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> _viewTouchHandler;
- private TouchCallbackDelegate _viewTouchCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate bool HoverCallbackDelegate(IntPtr view, IntPtr hover);
- private DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> _viewHoverHandler;
- private HoverCallbackDelegate _viewHoverCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate bool WheelCallbackDelegate(IntPtr view, IntPtr wheel);
- private DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> _viewWheelHandler;
- private WheelCallbackDelegate _viewWheelCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void OnStageEventCallbackDelegate(IntPtr control);
- private DaliEventHandler<object,OnStageEventArgs> _viewOnStageEventHandler;
- private OnStageEventCallbackDelegate _viewOnStageEventCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void OffStageEventCallbackDelegate(IntPtr control);
- private DaliEventHandler<object,OffStageEventArgs> _viewOffStageEventHandler;
- private OffStageEventCallbackDelegate _viewOffStageEventCallbackDelegate;
-
- /**
- * @brief Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of KeyInputFocusGainedEventHandler-DaliEventHandler<object,KeyInputFocusGainedEventArgs>)
- * provided by the user. KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
- */
- public event DaliEventHandler<object,KeyInputFocusGainedEventArgs> KeyInputFocusGained
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_KeyInputFocusGainedEventHandler == null)
+ /**
+ * @brief Event arguments that passed via KeyInputFocusLost signal
+ *
+ */
+ public class KeyInputFocusLostEventArgs : EventArgs
{
- _KeyInputFocusGainedEventHandler += value;
- Console.WriteLine("View Key EVENT Locked....");
- _KeyInputFocusGainedCallbackDelegate = new KeyInputFocusGainedCallbackDelegate(OnKeyInputFocusGained);
- this.KeyInputFocusGainedSignal().Connect(_KeyInputFocusGainedCallbackDelegate);
+ private View _view;
+
+ /**
+ * @brief View - is the view that loses Key Input Focus
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
}
- }
- }
- remove
- {
- lock(this)
- {
- if (_KeyInputFocusGainedEventHandler != null)
+ /**
+ * @brief Event arguments that passed via Key signal
+ *
+ */
+ public class KeyEventArgs : EventArgs
{
- this.KeyInputFocusGainedSignal().Disconnect(_KeyInputFocusGainedCallbackDelegate);
+ private View _view;
+ private Key _key;
+
+ /**
+ * @brief View - is the view that recieves the key.
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+
+ /**
+ * @brief Key - is the key sent to the View.
+ *
+ */
+ public Key Key
+ {
+ get
+ {
+ return _key;
+ }
+ set
+ {
+ _key = value;
+ }
+ }
}
- _KeyInputFocusGainedEventHandler -= value;
- }
- }
- }
+ /**
+ * @brief Event arguments that passed via OnRelayout signal
+ *
+ */
+ public class OnRelayoutEventArgs : EventArgs
+ {
+ private View _view;
+
+ /**
+ * @brief View - is the view that is being resized upon relayout
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+ }
- private void OnKeyInputFocusGained(IntPtr view)
- {
- KeyInputFocusGainedEventArgs e = new KeyInputFocusGainedEventArgs();
- Console.WriteLine("View Key ....");
- // Populate all members of "e" (KeyInputFocusGainedEventArgs) with real data
- e.View = Dali.View.GetViewFromPtr(view);
- if (_KeyInputFocusGainedEventHandler != null)
- {
- //here we send all data to user event handlers
- _KeyInputFocusGainedEventHandler(this, e);
- }
+ /**
+ * @brief Event arguments that passed via Touch signal
+ *
+ */
+ public class TouchEventArgs : EventArgs
+ {
+ private View _view;
+ private Touch _touch;
+
+ /**
+ * @brief View - is the view that is being touched
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+
+ /**
+ * @brief Touch - contains the information of touch points
+ *
+ */
+ public Touch Touch
+ {
+ get
+ {
+ return _touch;
+ }
+ set
+ {
+ _touch = value;
+ }
+ }
+ }
- }
+ /**
+ * @brief Event arguments that passed via Hover signal
+ *
+ */
+ public class HoverEventArgs : EventArgs
+ {
+ private View _view;
+ private Hover _hover;
+
+ /**
+ * @brief View - is the view that is being hovered
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+
+ /**
+ * @brief Hover - contains touch points that represent the points
+ * that are currently being hovered or the points where a hover has stopped
+ *
+ */
+ public Hover Hover
+ {
+ get
+ {
+ return _hover;
+ }
+ set
+ {
+ _hover = value;
+ }
+ }
+ }
- /**
- * @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of KeyInputFocusLostEventHandler-DaliEventHandler<object,KeyInputFocusLostEventArgs>)
- * provided by the user. KeyInputFocusLost signal is emitted when the control loses Key Input Focus.
- */
- public event DaliEventHandler<object,KeyInputFocusLostEventArgs> KeyInputFocusLost
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_KeyInputFocusLostEventHandler == null)
+ /**
+ * @brief Event arguments that passed via Wheel signal
+ *
+ */
+ public class WheelEventArgs : EventArgs
{
- _KeyInputFocusLostEventHandler += value;
+ private View _view;
+ private Wheel _wheel;
+
+ /**
+ * @brief View - is the view that is being wheeled
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+
+ /**
+ * @brief Wheel - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
+ *
+ */
+ public Wheel Wheel
+ {
+ get
+ {
+ return _wheel;
+ }
+ set
+ {
+ _wheel = value;
+ }
+ }
+ }
- _KeyInputFocusLostCallbackDelegate = new KeyInputFocusLostCallbackDelegate(OnKeyInputFocusLost);
- this.KeyInputFocusLostSignal().Connect(_KeyInputFocusLostCallbackDelegate);
+ /**
+ * @brief Event arguments that passed via OnWindow signal
+ *
+ */
+ public class OnWindowEventArgs : EventArgs
+ {
+ private View _view;
+
+ /**
+ * @brief View - is the view that is being connected to the window
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
}
- }
- }
- remove
- {
- lock(this)
- {
- if (_KeyInputFocusLostEventHandler != null)
+ /**
+ * @brief Event arguments that passed via OffWindow signal
+ *
+ */
+ public class OffWindowEventArgs : EventArgs
{
- this.KeyInputFocusLostSignal().Disconnect(_KeyInputFocusLostCallbackDelegate);
+ private View _view;
+
+ /**
+ * @brief View - is the view that is being disconnected from the window
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
}
- _KeyInputFocusLostEventHandler -= value;
- }
- }
- }
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr control);
- private void OnKeyInputFocusLost(IntPtr view)
- {
- KeyInputFocusLostEventArgs e = new KeyInputFocusLostEventArgs();
+ private DaliEventHandler<object,KeyInputFocusGainedEventArgs> _KeyInputFocusGainedEventHandler;
+ private KeyInputFocusGainedCallbackDelegate _KeyInputFocusGainedCallbackDelegate;
- // Populate all members of "e" (KeyInputFocusLostEventArgs) with real data
- e.View = Dali.View.GetViewFromPtr(view);
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void KeyInputFocusLostCallbackDelegate(IntPtr control);
- if (_KeyInputFocusLostEventHandler != null)
- {
- //here we send all data to user event handlers
- _KeyInputFocusLostEventHandler(this, e);
- }
- }
-
- /**
- * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of KeyHandler-DaliEventHandlerWithReturnType<object,KeyEventArgs,bool>)
- * provided by the user. KeyPressed signal is emitted when key event is received.
- */
- public event DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> KeyPressed
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_KeyHandler == null)
+ private DaliEventHandler<object,KeyInputFocusLostEventArgs> _KeyInputFocusLostEventHandler;
+ private KeyInputFocusLostCallbackDelegate _KeyInputFocusLostCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate bool KeyCallbackDelegate(IntPtr control, IntPtr key);
+
+ private DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> _KeyHandler;
+ private KeyCallbackDelegate _KeyCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void OnRelayoutEventCallbackDelegate(IntPtr control);
+
+ private DaliEventHandler<object,OnRelayoutEventArgs> _viewOnRelayoutEventHandler;
+ private OnRelayoutEventCallbackDelegate _viewOnRelayoutEventCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate bool TouchCallbackDelegate(IntPtr view, IntPtr touch);
+
+ private DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> _viewTouchHandler;
+ private TouchCallbackDelegate _viewTouchCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate bool HoverCallbackDelegate(IntPtr view, IntPtr hover);
+
+ private DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> _viewHoverHandler;
+ private HoverCallbackDelegate _viewHoverCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate bool WheelCallbackDelegate(IntPtr view, IntPtr wheel);
+
+ private DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> _viewWheelHandler;
+ private WheelCallbackDelegate _viewWheelCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void OnWindowEventCallbackDelegate(IntPtr control);
+
+ private DaliEventHandler<object,OnWindowEventArgs> _viewOnWindowEventHandler;
+ private OnWindowEventCallbackDelegate _viewOnWindowEventCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void OffWindowEventCallbackDelegate(IntPtr control);
+
+ private DaliEventHandler<object,OffWindowEventArgs> _viewOffWindowEventHandler;
+ private OffWindowEventCallbackDelegate _viewOffWindowEventCallbackDelegate;
+
+ /**
+ * @brief Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of KeyInputFocusGainedEventHandler-DaliEventHandler<object,KeyInputFocusGainedEventArgs>)
+ * provided by the user. KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
+ */
+ public event DaliEventHandler<object,KeyInputFocusGainedEventArgs> KeyInputFocusGained
+ {
+ add
+ {
+ lock (this)
+ {
+ // Restricted to only one listener
+ if (_KeyInputFocusGainedEventHandler == null)
+ {
+ _KeyInputFocusGainedEventHandler += value;
+ Console.WriteLine("View Key EVENT Locked....");
+ _KeyInputFocusGainedCallbackDelegate = new KeyInputFocusGainedCallbackDelegate(OnKeyInputFocusGained);
+ this.KeyInputFocusGainedSignal().Connect(_KeyInputFocusGainedCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock (this)
+ {
+ if (_KeyInputFocusGainedEventHandler != null)
+ {
+ this.KeyInputFocusGainedSignal().Disconnect(_KeyInputFocusGainedCallbackDelegate);
+ }
+
+ _KeyInputFocusGainedEventHandler -= value;
+ }
+ }
+ }
+
+ private void OnKeyInputFocusGained(IntPtr view)
{
- _KeyHandler += value;
+ KeyInputFocusGainedEventArgs e = new KeyInputFocusGainedEventArgs();
+ Console.WriteLine("View Key ....");
+ // Populate all members of "e" (KeyInputFocusGainedEventArgs) with real data
+ e.View = Dali.View.GetViewFromPtr(view);
+
+ if (_KeyInputFocusGainedEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _KeyInputFocusGainedEventHandler(this, e);
+ }
- _KeyCallbackDelegate = new KeyCallbackDelegate(OnKey);
- this.KeyEventSignal().Connect(_KeyCallbackDelegate);
}
- }
- }
- remove
- {
- lock(this)
- {
- if (_KeyHandler != null)
+ /**
+ * @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of KeyInputFocusLostEventHandler-DaliEventHandler<object,KeyInputFocusLostEventArgs>)
+ * provided by the user. KeyInputFocusLost signal is emitted when the control loses Key Input Focus.
+ */
+ public event DaliEventHandler<object,KeyInputFocusLostEventArgs> KeyInputFocusLost
{
- this.KeyEventSignal().Disconnect(_KeyCallbackDelegate);
+ add
+ {
+ lock (this)
+ {
+ // Restricted to only one listener
+ if (_KeyInputFocusLostEventHandler == null)
+ {
+ _KeyInputFocusLostEventHandler += value;
+
+ _KeyInputFocusLostCallbackDelegate = new KeyInputFocusLostCallbackDelegate(OnKeyInputFocusLost);
+ this.KeyInputFocusLostSignal().Connect(_KeyInputFocusLostCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock (this)
+ {
+ if (_KeyInputFocusLostEventHandler != null)
+ {
+ this.KeyInputFocusLostSignal().Disconnect(_KeyInputFocusLostCallbackDelegate);
+ }
+
+ _KeyInputFocusLostEventHandler -= value;
+ }
+ }
}
- _KeyHandler -= value;
- }
- }
- }
+ private void OnKeyInputFocusLost(IntPtr view)
+ {
+ KeyInputFocusLostEventArgs e = new KeyInputFocusLostEventArgs();
- private bool OnKey(IntPtr view, IntPtr key)
- {
- KeyEventArgs e = new KeyEventArgs();
+ // Populate all members of "e" (KeyInputFocusLostEventArgs) with real data
+ e.View = Dali.View.GetViewFromPtr(view);
- // Populate all members of "e" (KeyEventArgs) with real data
- e.View = Dali.View.GetViewFromPtr(view);
- e.Key = Dali.Key.GetKeyFromPtr(key);
+ if (_KeyInputFocusLostEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _KeyInputFocusLostEventHandler(this, e);
+ }
+ }
- if (_KeyHandler != null)
- {
- //here we send all data to user event handlers
- return _KeyHandler(this, e);
- }
- return false;
-
- }
-
- /**
- * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of OnRelayoutEventHandler) provided by the user.
- * OnRelayout signal is emitted after the size has been set on the view during relayout.
- */
- public event DaliEventHandler<object,OnRelayoutEventArgs> OnRelayoutEvent
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_viewOnRelayoutEventHandler == null)
+ /**
+ * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of KeyHandler-DaliEventHandlerWithReturnType<object,KeyEventArgs,bool>)
+ * provided by the user. KeyPressed signal is emitted when key event is received.
+ */
+ public event DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> KeyPressed
{
- _viewOnRelayoutEventHandler += value;
- Console.WriteLine("View OnRelayoutEventArgs Locked....");
- _viewOnRelayoutEventCallbackDelegate = new OnRelayoutEventCallbackDelegate(OnRelayout);
- this.OnRelayoutSignal().Connect(_viewOnRelayoutEventCallbackDelegate);
+ add
+ {
+ lock (this)
+ {
+ // Restricted to only one listener
+ if (_KeyHandler == null)
+ {
+ _KeyHandler += value;
+
+ _KeyCallbackDelegate = new KeyCallbackDelegate(OnKey);
+ this.KeyEventSignal().Connect(_KeyCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock (this)
+ {
+ if (_KeyHandler != null)
+ {
+ this.KeyEventSignal().Disconnect(_KeyCallbackDelegate);
+ }
+
+ _KeyHandler -= value;
+ }
+ }
}
- }
- }
- remove
- {
- lock(this)
- {
- if (_viewOnRelayoutEventHandler != null)
+ private bool OnKey(IntPtr view, IntPtr key)
{
- this.OnRelayoutSignal().Disconnect(_viewOnRelayoutEventCallbackDelegate);
- }
+ KeyEventArgs e = new KeyEventArgs();
- _viewOnRelayoutEventHandler -= value;
- }
- }
- }
+ // Populate all members of "e" (KeyEventArgs) with real data
+ e.View = Dali.View.GetViewFromPtr(view);
+ e.Key = Dali.Key.GetKeyFromPtr(key);
- // Callback for View OnRelayout signal
- private void OnRelayout(IntPtr data)
- {
- OnRelayoutEventArgs e = new OnRelayoutEventArgs();
- Console.WriteLine("View OnRelayoutEventArgs....");
- // Populate all members of "e" (OnRelayoutEventArgs) with real data
- e.View = View.GetViewFromPtr(data);
+ if (_KeyHandler != null)
+ {
+ //here we send all data to user event handlers
+ return _KeyHandler(this, e);
+ }
+ return false;
- if (_viewOnRelayoutEventHandler != null)
- {
- //here we send all data to user event handlers
- _viewOnRelayoutEventHandler(this, e);
- }
- }
-
- /**
- * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of TouchHandler-DaliEventHandlerWithReturnType<object,TouchEventArgs,bool>)
- * provided by the user. Touched signal is emitted when touch input is received.
- */
- public event DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> Touched
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_viewTouchHandler == null)
- {
- _viewTouchHandler += value;
- Console.WriteLine("View Touch EVENT LOCKED....");
- _viewTouchCallbackDelegate = new TouchCallbackDelegate(OnTouch);
- this.TouchSignal().Connect(_viewTouchCallbackDelegate);
}
- }
- }
- remove
- {
- lock(this)
- {
- if (_viewTouchHandler != null)
+ /**
+ * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of OnRelayoutEventHandler) provided by the user.
+ * OnRelayout signal is emitted after the size has been set on the view during relayout.
+ */
+ public event DaliEventHandler<object,OnRelayoutEventArgs> OnRelayoutEvent
{
- this.TouchSignal().Disconnect(_viewTouchCallbackDelegate);
+ add
+ {
+ lock (this)
+ {
+ // Restricted to only one listener
+ if (_viewOnRelayoutEventHandler == null)
+ {
+ _viewOnRelayoutEventHandler += value;
+ Console.WriteLine("View OnRelayoutEventArgs Locked....");
+ _viewOnRelayoutEventCallbackDelegate = new OnRelayoutEventCallbackDelegate(OnRelayout);
+ this.OnRelayoutSignal().Connect(_viewOnRelayoutEventCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock (this)
+ {
+ if (_viewOnRelayoutEventHandler != null)
+ {
+ this.OnRelayoutSignal().Disconnect(_viewOnRelayoutEventCallbackDelegate);
+ }
+
+ _viewOnRelayoutEventHandler -= value;
+ }
+ }
}
- _viewTouchHandler -= value;
- }
- }
- }
-
- // Callback for View TouchSignal
- private bool OnTouch(IntPtr view, IntPtr touch)
- {
- TouchEventArgs e = new TouchEventArgs();
- Console.WriteLine("View Touch EVENT....");
- // Populate all members of "e" (TouchEventArgs) with real data
- e.View = View.GetViewFromPtr(view);
- e.Touch = Dali.Touch.GetTouchFromPtr(touch);
-
- if (_viewTouchHandler != null)
- {
- //here we send all data to user event handlers
- return _viewTouchHandler(this, e);
- }
+ // Callback for View OnRelayout signal
+ private void OnRelayout(IntPtr data)
+ {
+ OnRelayoutEventArgs e = new OnRelayoutEventArgs();
+ Console.WriteLine("View OnRelayoutEventArgs....");
+ // Populate all members of "e" (OnRelayoutEventArgs) with real data
+ e.View = View.GetViewFromPtr(data);
+
+ if (_viewOnRelayoutEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _viewOnRelayoutEventHandler(this, e);
+ }
+ }
- return false;
- }
-
- /**
- * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of HoverHandler-DaliEventHandlerWithReturnType<object,HoverEventArgs,bool>)
- * provided by the user. Hovered signal is emitted when hover input is received.
- */
- public event DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> Hovered
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_viewHoverHandler == null)
+ /**
+ * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of TouchHandler-DaliEventHandlerWithReturnType<object,TouchEventArgs,bool>)
+ * provided by the user. Touched signal is emitted when touch input is received.
+ */
+ public event DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> Touched
{
- _viewHoverHandler += value;
+ add
+ {
+ lock (this)
+ {
+ // Restricted to only one listener
+ if (_viewTouchHandler == null)
+ {
+ _viewTouchHandler += value;
+ Console.WriteLine("View Touch EVENT LOCKED....");
+ _viewTouchCallbackDelegate = new TouchCallbackDelegate(OnTouch);
+ this.TouchSignal().Connect(_viewTouchCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock (this)
+ {
+ if (_viewTouchHandler != null)
+ {
+ this.TouchSignal().Disconnect(_viewTouchCallbackDelegate);
+ }
+
+ _viewTouchHandler -= value;
+ }
+ }
+ }
- _viewHoverCallbackDelegate = new HoverCallbackDelegate(OnHover);
- this.HoveredSignal().Connect(_viewHoverCallbackDelegate);
+ // Callback for View TouchSignal
+ private bool OnTouch(IntPtr view, IntPtr touch)
+ {
+ TouchEventArgs e = new TouchEventArgs();
+ Console.WriteLine("View Touch EVENT....");
+ // Populate all members of "e" (TouchEventArgs) with real data
+ e.View = View.GetViewFromPtr(view);
+ e.Touch = Dali.Touch.GetTouchFromPtr(touch);
+
+ if (_viewTouchHandler != null)
+ {
+ //here we send all data to user event handlers
+ return _viewTouchHandler(this, e);
+ }
+
+ return false;
}
- }
- }
- remove
- {
- lock(this)
- {
- if (_viewHoverHandler != null)
+ /**
+ * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of HoverHandler-DaliEventHandlerWithReturnType<object,HoverEventArgs,bool>)
+ * provided by the user. Hovered signal is emitted when hover input is received.
+ */
+ public event DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> Hovered
{
- this.HoveredSignal().Disconnect(_viewHoverCallbackDelegate);
+ add
+ {
+ lock (this)
+ {
+ // Restricted to only one listener
+ if (_viewHoverHandler == null)
+ {
+ _viewHoverHandler += value;
+
+ _viewHoverCallbackDelegate = new HoverCallbackDelegate(OnHover);
+ this.HoveredSignal().Connect(_viewHoverCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock (this)
+ {
+ if (_viewHoverHandler != null)
+ {
+ this.HoveredSignal().Disconnect(_viewHoverCallbackDelegate);
+ }
+
+ _viewHoverHandler -= value;
+ }
+ }
}
- _viewHoverHandler -= value;
- }
- }
- }
+ // Callback for View Hover signal
+ private bool OnHover(IntPtr view, IntPtr hover)
+ {
+ HoverEventArgs e = new HoverEventArgs();
- // Callback for View Hover signal
- private bool OnHover(IntPtr view, IntPtr hover)
- {
- HoverEventArgs e = new HoverEventArgs();
+ // Populate all members of "e" (HoverEventArgs) with real data
+ e.View = View.GetViewFromPtr(view);
+ e.Hover = Dali.Hover.GetHoverFromPtr(hover);
- // Populate all members of "e" (HoverEventArgs) with real data
- e.View = View.GetViewFromPtr(view);
- e.Hover = Dali.Hover.GetHoverFromPtr(hover);
+ if (_viewHoverHandler != null)
+ {
+ //here we send all data to user event handlers
+ return _viewHoverHandler(this, e);
+ }
- if (_viewHoverHandler != null)
- {
- //here we send all data to user event handlers
- return _viewHoverHandler(this, e);
- }
+ return false;
+ }
- return false;
- }
-
- /**
- * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of WheelHandler-DaliEventHandlerWithReturnType<object,WheelEventArgs,bool>)
- * provided by the user. WheelMoved signal is emitted when wheel event is received.
- */
- public event DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> WheelMoved
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_viewWheelHandler == null)
+ /**
+ * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of WheelHandler-DaliEventHandlerWithReturnType<object,WheelEventArgs,bool>)
+ * provided by the user. WheelMoved signal is emitted when wheel event is received.
+ */
+ public event DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> WheelMoved
{
- _viewWheelHandler += value;
- Console.WriteLine("View Wheel EVENT LOCKED....");
- _viewWheelCallbackDelegate = new WheelCallbackDelegate(OnWheel);
- this.WheelEventSignal().Connect(_viewWheelCallbackDelegate);
+ add
+ {
+ lock (this)
+ {
+ // Restricted to only one listener
+ if (_viewWheelHandler == null)
+ {
+ _viewWheelHandler += value;
+ Console.WriteLine("View Wheel EVENT LOCKED....");
+ _viewWheelCallbackDelegate = new WheelCallbackDelegate(OnWheel);
+ this.WheelEventSignal().Connect(_viewWheelCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock (this)
+ {
+ if (_viewWheelHandler != null)
+ {
+ this.WheelEventSignal().Disconnect(_viewWheelCallbackDelegate);
+ }
+
+ _viewWheelHandler -= value;
+ }
+ }
}
- }
- }
- remove
- {
- lock(this)
- {
- if (_viewWheelHandler != null)
+ // Callback for View Wheel signal
+ private bool OnWheel(IntPtr view, IntPtr wheel)
{
- this.WheelEventSignal().Disconnect(_viewWheelCallbackDelegate);
+ WheelEventArgs e = new WheelEventArgs();
+ Console.WriteLine("View Wheel EVENT ....");
+ // Populate all members of "e" (WheelEventArgs) with real data
+ e.View = View.GetViewFromPtr(view);
+ e.Wheel = Dali.Wheel.GetWheelFromPtr(wheel);
+
+ if (_viewWheelHandler != null)
+ {
+ //here we send all data to user event handlers
+ return _viewWheelHandler(this, e);
+ }
+
+ return false;
}
- _viewWheelHandler -= value;
- }
- }
- }
-
- // Callback for View Wheel signal
- private bool OnWheel(IntPtr view, IntPtr wheel)
- {
- WheelEventArgs e = new WheelEventArgs();
- Console.WriteLine("View Wheel EVENT ....");
- // Populate all members of "e" (WheelEventArgs) with real data
- e.View = View.GetViewFromPtr(view);
- e.Wheel = Dali.Wheel.GetWheelFromPtr(wheel);
-
- if (_viewWheelHandler != null)
- {
- //here we send all data to user event handlers
- return _viewWheelHandler(this, e);
- }
+ /**
+ * @brief Event for OnWindow signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of OnWindowEventHandler) provided by the user.
+ * OnWindow signal is emitted after the view has been connected to the window.
+ */
+ public event DaliEventHandler<object,OnWindowEventArgs> OnWindowEvent
+ {
+ add
+ {
+ lock (this)
+ {
+ // Restricted to only one listener
+ if (_viewOnWindowEventHandler == null)
+ {
+ _viewOnWindowEventHandler += value;
+
+ _viewOnWindowEventCallbackDelegate = new OnWindowEventCallbackDelegate(OnWindow);
+ this.OnWindowSignal().Connect(_viewOnWindowEventCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock (this)
+ {
+ if (_viewOnWindowEventHandler != null)
+ {
+ this.OnWindowSignal().Disconnect(_viewOnWindowEventCallbackDelegate);
+ }
+
+ _viewOnWindowEventHandler -= value;
+ }
+ }
+ }
- return false;
- }
-
- /**
- * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of OnStageEventHandler) provided by the user.
- * OnStage signal is emitted after the view has been connected to the stage.
- */
- public event DaliEventHandler<object,OnStageEventArgs> OnStageEvent
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_viewOnStageEventHandler == null)
+ // Callback for View OnWindow signal
+ private void OnWindow(IntPtr data)
{
- _viewOnStageEventHandler += value;
+ OnWindowEventArgs e = new OnWindowEventArgs();
+
+ // Populate all members of "e" (OnWindowEventArgs) with real data
+ e.View = View.GetViewFromPtr(data);
- _viewOnStageEventCallbackDelegate = new OnStageEventCallbackDelegate(OnStage);
- this.OnStageSignal().Connect(_viewOnStageEventCallbackDelegate);
+ //Console.WriteLine("############# OnWindow()! e.View.Name=" + e.View.Name);
+
+ if (_viewOnWindowEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _viewOnWindowEventHandler(this, e);
+ }
}
- }
- }
- remove
- {
- lock(this)
- {
- if (_viewOnStageEventHandler != null)
+ /**
+ * @brief Event for OffWindow signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of OffWindowEventHandler) provided by the user.
+ * OffWindow signal is emitted after the view has been disconnected from the window.
+ */
+ public event DaliEventHandler<object,OffWindowEventArgs> OffWindowEvent
{
- this.OnStageSignal().Disconnect(_viewOnStageEventCallbackDelegate);
+ add
+ {
+ lock (this)
+ {
+ // Restricted to only one listener
+ if (_viewOffWindowEventHandler == null)
+ {
+ _viewOffWindowEventHandler += value;
+
+ _viewOffWindowEventCallbackDelegate = new OffWindowEventCallbackDelegate(OffWindow);
+ this.OnWindowSignal().Connect(_viewOffWindowEventCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock (this)
+ {
+ if (_viewOffWindowEventHandler != null)
+ {
+ this.OnWindowSignal().Disconnect(_viewOffWindowEventCallbackDelegate);
+ }
+
+ _viewOffWindowEventHandler -= value;
+ }
+ }
}
- _viewOnStageEventHandler -= value;
- }
- }
- }
+ // Callback for View OffWindow signal
+ private void OffWindow(IntPtr data)
+ {
+ OffWindowEventArgs e = new OffWindowEventArgs();
- // Callback for View OnStage signal
- private void OnStage(IntPtr data)
- {
- OnStageEventArgs e = new OnStageEventArgs();
+ // Populate all members of "e" (OffWindowEventArgs) with real data
+ e.View = View.GetViewFromPtr(data);
- // Populate all members of "e" (OnStageEventArgs) with real data
- e.View = View.GetViewFromPtr(data);
+ if (_viewOffWindowEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _viewOffWindowEventHandler(this, e);
+ }
+ }
- //Console.WriteLine("############# OnStage()! e.View.Name=" + e.View.Name);
+ public static View GetViewFromPtr(global::System.IntPtr cPtr)
+ {
+ View ret = new View(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- if (_viewOnStageEventHandler != null)
- {
- //here we send all data to user event handlers
- _viewOnStageEventHandler(this, e);
- }
- }
-
- /**
- * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of OffStageEventHandler) provided by the user.
- * OffStage signal is emitted after the view has been disconnected from the stage.
- */
- public event DaliEventHandler<object,OffStageEventArgs> OffStageEvent
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_viewOffStageEventHandler == null)
+ public IntPtr GetPtrfromView()
+ {
+ return (IntPtr)swigCPtr;
+ }
+
+ public class Property : global::System.IDisposable
{
- _viewOffStageEventHandler += value;
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
+ {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
+ {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~Property()
+ {
+ Dispose();
+ }
+
+ public virtual void Dispose()
+ {
+ lock (this)
+ {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero)
+ {
+ if (swigCMemOwn)
+ {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_View_Property(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
+
+ public static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();
+ public static readonly int STATE = NDalicManualPINVOKE.View_Property_STATE_get();
+ public static readonly int SUB_STATE = NDalicManualPINVOKE.View_Property_SUB_STATE_get();
+ public static readonly int LEFT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_LEFT_FOCUSABLE_ACTOR_ID_get();
+ public static readonly int RIGHT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get();
+ public static readonly int UP_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_UP_FOCUSABLE_ACTOR_ID_get();
+ public static readonly int DOWN_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_DOWN_FOCUSABLE_ACTOR_ID_get();
+
+ public Property() : this(NDalicPINVOKE.new_View_Property(), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public static readonly int STYLE_NAME = NDalicPINVOKE.View_Property_STYLE_NAME_get();
+ public static readonly int BACKGROUND_COLOR = NDalicPINVOKE.View_Property_BACKGROUND_COLOR_get();
+ public static readonly int BACKGROUND_IMAGE = NDalicPINVOKE.View_Property_BACKGROUND_IMAGE_get();
+ public static readonly int KEY_INPUT_FOCUS = NDalicPINVOKE.View_Property_KEY_INPUT_FOCUS_get();
+ public static readonly int BACKGROUND = NDalicPINVOKE.View_Property_BACKGROUND_get();
+
+
+ public static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
+ public static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
+ public static readonly int SCREEN_POSITION = NDalicManualPINVOKE.Actor_Property_SCREEN_POSITION_get();
+ public static readonly int POSITION_USES_ANCHOR_POINT = NDalicManualPINVOKE.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
+ public static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
+ public static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
+ public static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
+ public static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
+ public static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
+ public static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
+ public static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
+ public static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
+ public static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
+ public static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
+ public static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
+ public static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
+ public static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
+ public static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
+ public static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
+ public static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
+ public static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
+ public static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
+ public static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
+ public static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
+ public static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
+ public static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
+ public static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
+ public static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
+ public static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
+ public static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
+ public static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
+ public static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
+ public static readonly int COLOR = NDalicPINVOKE.Actor_Property_COLOR_get();
+ public static readonly int COLOR_RED = NDalicPINVOKE.Actor_Property_COLOR_RED_get();
+ public static readonly int COLOR_GREEN = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();
+ public static readonly int COLOR_BLUE = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();
+ public static readonly int COLOR_ALPHA = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();
+ public static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
+ public static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
+ public static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
+ public static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
+ public static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
+ public static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
+ public static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
+ public static readonly int COLOR_MODE = NDalicPINVOKE.Actor_Property_COLOR_MODE_get();
+ public static readonly int POSITION_INHERITANCE = NDalicPINVOKE.Actor_Property_POSITION_INHERITANCE_get();
+ public static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
+ public static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
+ public static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
+ public static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
+ public static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
+ public static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
+ public static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
+ public static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
+ public static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
+ public static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
+ public static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
+ public static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
- _viewOffStageEventCallbackDelegate = new OffStageEventCallbackDelegate(OffStage);
- this.OnStageSignal().Connect(_viewOffStageEventCallbackDelegate);
}
- }
- }
- remove
- {
- lock(this)
- {
- if (_viewOffStageEventHandler != null)
+ public class KeyboardFocus : global::System.IDisposable
{
- this.OnStageSignal().Disconnect(_viewOffStageEventCallbackDelegate);
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal KeyboardFocus(global::System.IntPtr cPtr, bool cMemoryOwn)
+ {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(KeyboardFocus obj)
+ {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~KeyboardFocus()
+ {
+ Dispose();
+ }
+
+ public virtual void Dispose()
+ {
+ lock (this)
+ {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero)
+ {
+ if (swigCMemOwn)
+ {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_View_KeyboardFocus(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
+
+ public KeyboardFocus() : this(NDalicPINVOKE.new_View_KeyboardFocus(), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public enum Direction
+ {
+ LEFT,
+ RIGHT,
+ UP,
+ DOWN,
+ PAGE_UP,
+ PAGE_DOWN
+ }
}
- _viewOffStageEventHandler -= value;
- }
- }
- }
+ public View() : this(NDalicPINVOKE.View_New(), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- // Callback for View OffStage signal
- private void OffStage(IntPtr data)
- {
- OffStageEventArgs e = new OffStageEventArgs();
+ }
- // Populate all members of "e" (OffStageEventArgs) with real data
- e.View = View.GetViewFromPtr(data);
+ public View(View uiControl) : this(NDalicPINVOKE.new_View__SWIG_1(View.getCPtr(uiControl)), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- if (_viewOffStageEventHandler != null)
- {
- //here we send all data to user event handlers
- _viewOffStageEventHandler(this, e);
- }
- }
+ public View Assign(View handle)
+ {
+ View ret = new View(NDalicPINVOKE.View_Assign(swigCPtr, View.getCPtr(handle)), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public static View GetViewFromPtr(global::System.IntPtr cPtr) {
- View ret = new View(cPtr, false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
+ private new static View DownCast(BaseHandle handle)
+ {
+ View ret = new View(NDalicPINVOKE.View_DownCast(BaseHandle.getCPtr(handle)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public class Property : global::System.IDisposable {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- protected bool swigCMemOwn;
+ public static T DownCast<T>(View view) where T : View
+ {
+ return (T)(ViewRegistry.GetViewFromActor(view));
+ }
- internal Property(global::System.IntPtr cPtr, bool cMemoryOwn) {
- swigCMemOwn = cMemoryOwn;
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
+ private View ConvertIdToView(uint id)
+ {
+ View view = null;
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj) {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
+ if (Parent)
+ {
+ view = Parent.FindChildById(id);
+ }
- ~Property() {
- Dispose();
- }
+ if (!view)
+ {
+ view = Window.Instance.GetRootLayer().FindChildById(id);
+ }
- public virtual void Dispose() {
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_View_Property(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
+ return view;
+ }
- public static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();
- public static readonly int STATE = NDalicManualPINVOKE.View_Property_STATE_get();
- public static readonly int SUB_STATE = NDalicManualPINVOKE.View_Property_SUB_STATE_get();
- public static readonly int LEFT_FOCUSABLE_ACTOR_ID = NDalicManualPINVOKE.View_Property_LEFT_FOCUSABLE_ACTOR_ID_get();
- public static readonly int RIGHT_FOCUSABLE_ACTOR_ID = NDalicManualPINVOKE.View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get();
- public static readonly int UP_FOCUSABLE_ACTOR_ID = NDalicManualPINVOKE.View_Property_UP_FOCUSABLE_ACTOR_ID_get();
- public static readonly int DOWN_FOCUSABLE_ACTOR_ID = NDalicManualPINVOKE.View_Property_DOWN_FOCUSABLE_ACTOR_ID_get();
+ public void SetKeyInputFocus()
+ {
+ NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- public Property() : this(NDalicPINVOKE.new_View_Property(), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
+ public bool HasKeyInputFocus()
+ {
+ bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public static readonly int STYLE_NAME = NDalicPINVOKE.View_Property_STYLE_NAME_get();
- public static readonly int BACKGROUND_COLOR = NDalicPINVOKE.View_Property_BACKGROUND_COLOR_get();
- public static readonly int BACKGROUND_IMAGE = NDalicPINVOKE.View_Property_BACKGROUND_IMAGE_get();
- public static readonly int KEY_INPUT_FOCUS = NDalicPINVOKE.View_Property_KEY_INPUT_FOCUS_get();
- public static readonly int BACKGROUND = NDalicPINVOKE.View_Property_BACKGROUND_get();
+ public void ClearKeyInputFocus()
+ {
+ NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- }
+ public PinchGestureDetector GetPinchGestureDetector()
+ {
+ PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public class KeyboardFocus : global::System.IDisposable {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- protected bool swigCMemOwn;
+ public PanGestureDetector GetPanGestureDetector()
+ {
+ PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- internal KeyboardFocus(global::System.IntPtr cPtr, bool cMemoryOwn) {
- swigCMemOwn = cMemoryOwn;
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
+ public TapGestureDetector GetTapGestureDetector()
+ {
+ TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(KeyboardFocus obj) {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
+ public LongPressGestureDetector GetLongPressGestureDetector()
+ {
+ LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- ~KeyboardFocus() {
- Dispose();
- }
+ public void SetStyleName(string styleName)
+ {
+ NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- public virtual void Dispose() {
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_View_KeyboardFocus(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
+ public string GetStyleName()
+ {
+ string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public KeyboardFocus() : this(NDalicPINVOKE.new_View_KeyboardFocus(), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
+ public void SetBackgroundColor(Vector4 color)
+ {
+ NDalicPINVOKE.View_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- public enum Direction {
- LEFT,
- RIGHT,
- UP,
- DOWN,
- PAGE_UP,
- PAGE_DOWN
- }
- }
-
- public View () : this (NDalicPINVOKE.View_New(), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-
- }
- public View(View uiControl) : this(NDalicPINVOKE.new_View__SWIG_1(View.getCPtr(uiControl)), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public View Assign(View handle) {
- View ret = new View(NDalicPINVOKE.View_Assign(swigCPtr, View.getCPtr(handle)), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- private new static View DownCast(BaseHandle handle) {
- View ret = new View(NDalicPINVOKE.View_DownCast(BaseHandle.getCPtr(handle)), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public static T DownCast<T>(Actor actor) where T : View
- {
- return (T)( ViewRegistry.GetViewFromActor( actor ) );
- }
-
- private View ConvertIdToView(uint id)
- {
- Actor actor = null;
-
- if (Parent)
- {
- actor = Parent.FindChildById(id);
- }
+ public Vector4 GetBackgroundColor()
+ {
+ Vector4 ret = new Vector4(NDalicPINVOKE.View_GetBackgroundColor(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- if (!actor)
- {
- actor = Stage.Instance.GetRootLayer().FindChildById(id);
- }
+ public void SetBackgroundImage(Image image)
+ {
+ NDalicPINVOKE.View_SetBackgroundImage(swigCPtr, Image.getCPtr(image));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- return View.DownCast<View>(actor);
- }
-
- public void SetKeyInputFocus() {
- NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public bool HasKeyInputFocus() {
- bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void ClearKeyInputFocus() {
- NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public PinchGestureDetector GetPinchGestureDetector() {
- PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public PanGestureDetector GetPanGestureDetector() {
- PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public TapGestureDetector GetTapGestureDetector() {
- TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public LongPressGestureDetector GetLongPressGestureDetector() {
- LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetStyleName(string styleName) {
- NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public string GetStyleName() {
- string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetBackgroundColor(Vector4 color) {
- NDalicPINVOKE.View_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Vector4 GetBackgroundColor() {
- Vector4 ret = new Vector4(NDalicPINVOKE.View_GetBackgroundColor(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public void SetBackgroundImage(Image image) {
- NDalicPINVOKE.View_SetBackgroundImage(swigCPtr, Image.getCPtr(image));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void ClearBackground() {
- NDalicPINVOKE.View_ClearBackground(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public ControlKeySignal KeyEventSignal() {
- ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public KeyInputFocusSignal KeyInputFocusGainedSignal() {
- KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public KeyInputFocusSignal KeyInputFocusLostSignal() {
- KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public enum PropertyRange {
- PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
- CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,
- CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX+1000
- }
-
- public string StyleName
- {
- get
- {
- string temp;
- GetProperty( View.Property.STYLE_NAME).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( View.Property.STYLE_NAME, new Dali.Property.Value( value ) );
- }
- }
+ public void ClearBackground()
+ {
+ NDalicPINVOKE.View_ClearBackground(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- public Vector4 BackgroundColor
- {
- get
- {
- Vector4 backgroundColor = new Vector4(0.0f,0.0f,0.0f,0.0f);
+ public ControlKeySignal KeyEventSignal()
+ {
+ ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- Dali.Property.Map background = Background;
- int visualType = 0;
- background.Find( Dali.Constants.Visual.Property.Type ).Get( ref visualType );
- if(visualType == (int)Dali.Constants.Visual.Type.Color)
- {
- background.Find( Dali.Constants.ColorVisualProperty.MixColor ).Get( backgroundColor );
- }
+ public KeyInputFocusSignal KeyInputFocusGainedSignal()
+ {
+ KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- return backgroundColor;
- }
- set
- {
- SetProperty( View.Property.BACKGROUND, new Dali.Property.Value( value ) );
- }
- }
+ public KeyInputFocusSignal KeyInputFocusLostSignal()
+ {
+ KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public string BackgroundImage
- {
- get
- {
- string backgroundImage = "";
+ public View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true)
+ {
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- Dali.Property.Map background = Background;
- int visualType = 0;
- background.Find( Dali.Constants.Visual.Property.Type ).Get( ref visualType );
- if(visualType == (int)Dali.Constants.Visual.Type.Image)
- {
- background.Find( Dali.Constants.ImageVisualProperty.URL ).Get( out backgroundImage );
- }
+ public enum PropertyRange
+ {
+ PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
+ CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,
+ CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000
+ }
- return backgroundImage;
- }
- set
- {
- SetProperty( View.Property.BACKGROUND, new Dali.Property.Value( value ) );
- }
- }
+ public string StyleName
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.STYLE_NAME).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.STYLE_NAME, new Dali.Property.Value(value));
+ }
+ }
- public bool KeyInputFocus
- {
- get
- {
- bool temp = false;
- GetProperty( View.Property.KEY_INPUT_FOCUS).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( View.Property.KEY_INPUT_FOCUS, new Dali.Property.Value( value ) );
- }
- }
+ public Vector4 BackgroundColor
+ {
+ get
+ {
+ Vector4 backgroundColor = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+
+ Dali.Property.Map background = Background;
+ int visualType = 0;
+ background.Find(Dali.Constants.Visual.Property.Type).Get(ref visualType);
+ if (visualType == (int)Dali.Constants.Visual.Type.Color)
+ {
+ background.Find(Dali.Constants.ColorVisualProperty.MixColor).Get(backgroundColor);
+ }
+
+ return backgroundColor;
+ }
+ set
+ {
+ SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
+ }
+ }
- public Dali.Property.Map Background
- {
- get
- {
- Dali.Property.Map temp = new Dali.Property.Map();
- GetProperty( View.Property.BACKGROUND).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( View.Property.BACKGROUND, new Dali.Property.Value( value ) );
- }
- }
+ public string BackgroundImage
+ {
+ get
+ {
+ string backgroundImage = "";
+
+ Dali.Property.Map background = Background;
+ int visualType = 0;
+ background.Find(Dali.Constants.Visual.Property.Type).Get(ref visualType);
+ if (visualType == (int)Dali.Constants.Visual.Type.Image)
+ {
+ background.Find(Dali.Constants.ImageVisualProperty.URL).Get(out backgroundImage);
+ }
+
+ return backgroundImage;
+ }
+ set
+ {
+ SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
+ }
+ }
- public string State
- {
- get
- {
- string temp;
- GetProperty( View.Property.STATE).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( View.Property.STATE, new Dali.Property.Value( value ) );
- }
- }
+ public bool KeyInputFocus
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.KEY_INPUT_FOCUS).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.KEY_INPUT_FOCUS, new Dali.Property.Value(value));
+ }
+ }
- public string SubState
- {
- get
- {
- string temp;
- GetProperty( View.Property.SUB_STATE).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( View.Property.SUB_STATE, new Dali.Property.Value( value ) );
- }
- }
+ public Dali.Property.Map Background
+ {
+ get
+ {
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty(View.Property.BACKGROUND).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
+ }
+ }
- public Dali.Property.Map Tooltip
- {
- get
- {
- Dali.Property.Map temp = new Dali.Property.Map();
- GetProperty( View.Property.TOOLTIP).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( View.Property.TOOLTIP, new Dali.Property.Value( value ) );
- }
- }
+ public string State
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.STATE).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.STATE, new Dali.Property.Value(value));
+ }
+ }
- public string TooltipText
- {
- set
- {
- SetProperty( View.Property.TOOLTIP, new Dali.Property.Value( value ) );
- }
- }
+ public string SubState
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.SUB_STATE).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SUB_STATE, new Dali.Property.Value(value));
+ }
+ }
- private int LeftFocusableActorId
- {
- get
- {
- int temp = 0;
- GetProperty( View.Property.LEFT_FOCUSABLE_ACTOR_ID).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( View.Property.LEFT_FOCUSABLE_ACTOR_ID, new Dali.Property.Value( value ) );
- }
- }
+ public Dali.Property.Map Tooltip
+ {
+ get
+ {
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty(View.Property.TOOLTIP).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.TOOLTIP, new Dali.Property.Value(value));
+ }
+ }
+
+ public string TooltipText
+ {
+ set
+ {
+ SetProperty(View.Property.TOOLTIP, new Dali.Property.Value(value));
+ }
+ }
+
+ private int LeftFocusableViewId
+ {
+ get
+ {
+ int temp = 0;
+ GetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
+ }
+ }
+
+ private int RightFocusableViewId
+ {
+ get
+ {
+ int temp = 0;
+ GetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
+ }
+ }
+
+ private int UpFocusableViewId
+ {
+ get
+ {
+ int temp = 0;
+ GetProperty(View.Property.UP_FOCUSABLE_VIEW_ID).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.UP_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
+ }
+ }
+
+ private int DownFocusableViewId
+ {
+ get
+ {
+ int temp = 0;
+ GetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
+ }
+ }
+
+ public float Flex
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(FlexContainer.ChildProperty.FLEX).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(FlexContainer.ChildProperty.FLEX, new Dali.Property.Value(value));
+ }
+ }
+
+ public int AlignSelf
+ {
+ get
+ {
+ int temp = 0;
+ GetProperty(FlexContainer.ChildProperty.ALIGN_SELF).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(FlexContainer.ChildProperty.ALIGN_SELF, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector4 FlexMargin
+ {
+ get
+ {
+ Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+ GetProperty(FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(FlexContainer.ChildProperty.FLEX_MARGIN, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector2 CellIndex
+ {
+ get
+ {
+ Vector2 temp = new Vector2(0.0f, 0.0f);
+ GetProperty(TableView.ChildProperty.CELL_INDEX).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(TableView.ChildProperty.CELL_INDEX, new Dali.Property.Value(value));
+ }
+ }
+
+ public float RowSpan
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(TableView.ChildProperty.ROW_SPAN).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(TableView.ChildProperty.ROW_SPAN, new Dali.Property.Value(value));
+ }
+ }
+
+ public float ColumnSpan
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(TableView.ChildProperty.COLUMN_SPAN).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(TableView.ChildProperty.COLUMN_SPAN, new Dali.Property.Value(value));
+ }
+ }
+
+ public string CellHorizontalAlignment
+ {
+ get
+ {
+ string temp;
+ GetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Dali.Property.Value(value));
+ }
+ }
+
+ public string CellVerticalAlignment
+ {
+ get
+ {
+ string temp;
+ GetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Dali.Property.Value(value));
+ }
+ }
+
+ /**
+ * @brief The left focusable view.
+ * @note This will return NULL if not set.
+ * This will also return NULL if the specified left focusable view is not on window.
+ *
+ */
+ public View LeftFocusableView
+ {
+ // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
+ get
+ {
+ if (LeftFocusableViewId >= 0)
+ {
+ return ConvertIdToView((uint)LeftFocusableViewId);
+ }
+ return null;
+ }
+ set
+ {
+ LeftFocusableViewId = (int)value.GetId();
+ }
+ }
+
+ /**
+ * @brief The right focusable view.
+ * @note This will return NULL if not set.
+ * This will also return NULL if the specified right focusable view is not on window.
+ *
+ */
+ public View RightFocusableView
+ {
+ // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
+ get
+ {
+ if (RightFocusableViewId >= 0)
+ {
+ return ConvertIdToView((uint)RightFocusableViewId);
+ }
+ return null;
+ }
+ set
+ {
+ RightFocusableViewId = (int)value.GetId();
+ }
+ }
+
+ /**
+ * @brief The up focusable view.
+ * @note This will return NULL if not set.
+ * This will also return NULL if the specified up focusable view is not on window.
+ *
+ */
+ public View UpFocusableView
+ {
+ // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
+ get
+ {
+ if (UpFocusableViewId >= 0)
+ {
+ return ConvertIdToView((uint)UpFocusableViewId);
+ }
+ return null;
+ }
+ set
+ {
+ UpFocusableViewId = (int)value.GetId();
+ }
+ }
+
+ /**
+ * @brief The down focusable view.
+ * @note This will return NULL if not set.
+ * This will also return NULL if the specified down focusable view is not on window.
+ *
+ */
+ public View DownFocusableView
+ {
+ // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
+ get
+ {
+ if (DownFocusableViewId >= 0)
+ {
+ return ConvertIdToView((uint)DownFocusableViewId);
+ }
+ return null;
+ }
+ set
+ {
+ DownFocusableViewId = (int)value.GetId();
+ }
+ }
+
+ public Position CurrentPosition
+ {
+ get
+ {
+ return GetCurrentPosition();
+ }
+ }
+
+ public Size2D Size2D
+ {
+ get
+ {
+ Size temp = new Size(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.SIZE).Get(temp);
+ return new Size2D(temp);
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE, new Dali.Property.Value(new Size(value)));
+ }
+ }
+
+ public Size CurrentSize
+ {
+ get
+ {
+ return GetCurrentSize();
+ }
+ }
+
+ public View Parent
+ {
+ get
+ {
+ return GetParent();
+ }
+ }
+
+ public bool Visibility
+ {
+ get
+ {
+ return IsVisible();
+ }
+ }
+
+ public float Opacity
+ {
+ get
+ {
+ float temp = 0;
+ GetProperty(View.Property.OPACITY).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.OPACITY, new Dali.Property.Value(value));
+ }
+ }
+
+ public Position2D Position2D
+ {
+ get
+ {
+ Position temp = new Position(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.POSITION).Get(temp);
+ return new Position2D(temp);
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION, new Dali.Property.Value(new Position(value)));
+ }
+ }
+
+ public Vector2 ScreenPosition
+ {
+ get
+ {
+ Vector2 temp = new Vector2(0.0f, 0.0f);
+ GetProperty(View.Property.SCREEN_POSITION).Get(temp);
+ return temp;
+ }
+ }
+
+ protected bool PositionUsesAnchorPoint
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Dali.Property.Value(value));
+ }
+ }
+
+ public bool StateFocusEnable
+ {
+ get
+ {
+ return IsKeyboardFocusable();
+ }
+ set
+ {
+ SetKeyboardFocusable(value);
+ }
+ }
+
+ public bool IsOnWindow
+ {
+ get
+ {
+ return OnWindow();
+ }
+ }
+
+ public int SiblingOrder
+ {
+ get
+ {
+ int temp = 0;
+ GetProperty(View.Property.SIBLING_ORDER).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIBLING_ORDER, new Dali.Property.Value(value));
+ }
+ }
+
+ public void Show()
+ {
+ SetVisible(true);
+ }
+
+ public void Hide()
+ {
+ SetVisible(false);
+ }
+
+ public void Raise()
+ {
+ NDalicPINVOKE.Raise(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Lower()
+ {
+ NDalicPINVOKE.Lower(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void RaiseToTop()
+ {
+ NDalicPINVOKE.RaiseToTop(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void LowerToBottom()
+ {
+ NDalicPINVOKE.LowerToBottom(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void RaiseAbove(View target)
+ {
+ NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void LowerBelow(View target)
+ {
+ NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public string GetName()
+ {
+ string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetName(string name)
+ {
+ NDalicPINVOKE.Actor_SetName(swigCPtr, name);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public uint GetId()
+ {
+ uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public bool OnWindow()
+ {
+ bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Layer GetLayer()
+ {
+ Layer ret = new Layer(NDalicPINVOKE.Actor_GetLayer(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void Add(View child)
+ {
+ NDalicPINVOKE.Actor_Add(swigCPtr, View.getCPtr(child));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Remove(View child)
+ {
+ NDalicPINVOKE.Actor_Remove(swigCPtr, View.getCPtr(child));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Unparent()
+ {
+ NDalicPINVOKE.Actor_Unparent(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public uint GetChildCount()
+ {
+ uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public View GetChildAt(uint index)
+ {
+ View ret = new View(NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public View FindChildByName(string actorName)
+ {
+ View ret = new View(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, actorName), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public View FindChildById(uint id)
+ {
+ View ret = new View(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public View GetParent()
+ {
+ View ret = new View(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetParentOrigin(Vector3 origin)
+ {
+ NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Vector3 GetCurrentParentOrigin()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetAnchorPoint(Vector3 anchorPoint)
+ {
+ NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Vector3 GetCurrentAnchorPoint()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetSize(float width, float height)
+ {
+ NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetSize(float width, float height, float depth)
+ {
+ NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetSize(Vector2 size)
+ {
+ NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetSize(Vector3 size)
+ {
+ NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Vector3 GetTargetSize()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Vector3 GetCurrentSize()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Vector3 GetNaturalSize()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetPosition(float x, float y)
+ {
+ NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetPosition(float x, float y, float z)
+ {
+ NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetPosition(Vector3 position)
+ {
+ NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetX(float x)
+ {
+ NDalicPINVOKE.Actor_SetX(swigCPtr, x);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetY(float y)
+ {
+ NDalicPINVOKE.Actor_SetY(swigCPtr, y);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetZ(float z)
+ {
+ NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void TranslateBy(Vector3 distance)
+ {
+ NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Vector3 GetCurrentPosition()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Vector3 GetCurrentWorldPosition()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetInheritPosition(bool inherit)
+ {
+ NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public PositionInheritanceMode GetPositionInheritanceMode()
+ {
+ PositionInheritanceMode ret = (PositionInheritanceMode)NDalicPINVOKE.Actor_GetPositionInheritanceMode(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public bool IsPositionInherited()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetOrientation(Degree angle, Vector3 axis)
+ {
+ NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetOrientation(Radian angle, Vector3 axis)
+ {
+ NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetOrientation(Rotation orientation)
+ {
+ NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void RotateBy(Degree angle, Vector3 axis)
+ {
+ NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void RotateBy(Radian angle, Vector3 axis)
+ {
+ NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void RotateBy(Rotation relativeRotation)
+ {
+ NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Rotation GetCurrentOrientation()
+ {
+ Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetInheritOrientation(bool inherit)
+ {
+ NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool IsOrientationInherited()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Rotation GetCurrentWorldOrientation()
+ {
+ Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetScale(float scale)
+ {
+ NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetScale(float scaleX, float scaleY, float scaleZ)
+ {
+ NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetScale(Vector3 scale)
+ {
+ NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void ScaleBy(Vector3 relativeScale)
+ {
+ NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Vector3 GetCurrentScale()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Vector3 GetCurrentWorldScale()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetInheritScale(bool inherit)
+ {
+ NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool IsScaleInherited()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Matrix GetCurrentWorldMatrix()
+ {
+ Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetVisible(bool visible)
+ {
+ NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool IsVisible()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetOpacity(float opacity)
+ {
+ NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public float GetCurrentOpacity()
+ {
+ float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetColor(Vector4 color)
+ {
+ NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Vector4 GetCurrentColor()
+ {
+ Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetColorMode(ColorMode colorMode)
+ {
+ NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public ColorMode GetColorMode()
+ {
+ ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Vector4 GetCurrentWorldColor()
+ {
+ Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetDrawMode(DrawModeType drawMode)
+ {
+ NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public DrawModeType GetDrawMode()
+ {
+ DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetSensitive(bool sensitive)
+ {
+ NDalicPINVOKE.Actor_SetSensitive(swigCPtr, sensitive);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool IsSensitive()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsSensitive(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
+ {
+ bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetLeaveRequired(bool required)
+ {
+ NDalicPINVOKE.Actor_SetLeaveRequired(swigCPtr, required);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool GetLeaveRequired()
+ {
+ bool ret = NDalicPINVOKE.Actor_GetLeaveRequired(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetKeyboardFocusable(bool focusable)
+ {
+ NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool IsKeyboardFocusable()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
+ {
+ NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public ResizePolicyType GetResizePolicy(DimensionType dimension)
+ {
+ ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetSizeScalePolicy(SizeScalePolicyType policy)
+ {
+ NDalicPINVOKE.Actor_SetSizeScalePolicy(swigCPtr, (int)policy);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public SizeScalePolicyType GetSizeScalePolicy()
+ {
+ SizeScalePolicyType ret = (SizeScalePolicyType)NDalicPINVOKE.Actor_GetSizeScalePolicy(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetSizeModeFactor(Vector3 factor)
+ {
+ NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Vector3 GetSizeModeFactor()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public float GetHeightForWidth(float width)
+ {
+ float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public float GetWidthForHeight(float height)
+ {
+ float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public float GetRelayoutSize(DimensionType dimension)
+ {
+ float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetPadding(PaddingType padding)
+ {
+ NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void GetPadding(PaddingType paddingOut)
+ {
+ NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetMinimumSize(Vector2 size)
+ {
+ NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- private int RightFocusableActorId
- {
- get
- {
- int temp = 0;
- GetProperty( View.Property.RIGHT_FOCUSABLE_ACTOR_ID).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( View.Property.RIGHT_FOCUSABLE_ACTOR_ID, new Dali.Property.Value( value ) );
- }
- }
+ public Vector2 GetMinimumSize()
+ {
+ Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- private int UpFocusableActorId
- {
- get
- {
- int temp = 0;
- GetProperty( View.Property.UP_FOCUSABLE_ACTOR_ID).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( View.Property.UP_FOCUSABLE_ACTOR_ID, new Dali.Property.Value( value ) );
- }
- }
+ public void SetMaximumSize(Vector2 size)
+ {
+ NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- private int DownFocusableActorId
- {
- get
- {
- int temp = 0;
- GetProperty( View.Property.DOWN_FOCUSABLE_ACTOR_ID).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( View.Property.DOWN_FOCUSABLE_ACTOR_ID, new Dali.Property.Value( value ) );
- }
- }
+ public Vector2 GetMaximumSize()
+ {
+ Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public float Flex
- {
- get
- {
- float temp = 0.0f;
- GetProperty( FlexContainer.ChildProperty.FLEX).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( FlexContainer.ChildProperty.FLEX, new Dali.Property.Value( value ) );
- }
- }
+ public int GetHierarchyDepth()
+ {
+ int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public int AlignSelf
- {
- get
- {
- int temp = 0;
- GetProperty( FlexContainer.ChildProperty.ALIGN_SELF).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( FlexContainer.ChildProperty.ALIGN_SELF, new Dali.Property.Value( value ) );
- }
- }
+ public uint AddRenderer(Renderer renderer)
+ {
+ uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public Vector4 FlexMargin
- {
- get
- {
- Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
- GetProperty( FlexContainer.ChildProperty.FLEX_MARGIN).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( FlexContainer.ChildProperty.FLEX_MARGIN, new Dali.Property.Value( value ) );
- }
- }
+ public uint GetRendererCount()
+ {
+ uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public Vector2 CellIndex
- {
- get
- {
- Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( TableView.ChildProperty.CELL_INDEX).Get( temp );
- return temp;
- }
- set
- {
- SetProperty( TableView.ChildProperty.CELL_INDEX, new Dali.Property.Value( value ) );
- }
- }
+ public Renderer GetRendererAt(uint index)
+ {
+ Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public float RowSpan
- {
- get
- {
- float temp = 0.0f;
- GetProperty( TableView.ChildProperty.ROW_SPAN).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( TableView.ChildProperty.ROW_SPAN, new Dali.Property.Value( value ) );
- }
- }
+ public void RemoveRenderer(Renderer renderer)
+ {
+ NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- public float ColumnSpan
- {
- get
- {
- float temp = 0.0f;
- GetProperty( TableView.ChildProperty.COLUMN_SPAN).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( TableView.ChildProperty.COLUMN_SPAN, new Dali.Property.Value( value ) );
- }
- }
+ public void RemoveRenderer(uint index)
+ {
+ NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- public string CellHorizontalAlignment
- {
- get
- {
- string temp;
- GetProperty( TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Dali.Property.Value( value ) );
- }
- }
+ internal TouchDataSignal TouchSignal()
+ {
+ TouchDataSignal ret = new TouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- public string CellVerticalAlignment
- {
- get
- {
- string temp;
- GetProperty( TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get( out temp );
- return temp;
- }
- set
- {
- SetProperty( TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Dali.Property.Value( value ) );
- }
- }
-
- /**
- * @brief The left focusable view.
- * @note This will return NULL if not set.
- * This will also return NULL if the specified left focusable view is not on stage.
- *
- */
- public View LeftFocusableView
- {
- // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
- get
- {
- if (LeftFocusableActorId >= 0)
- {
- return ConvertIdToView((uint)LeftFocusableActorId);
- }
- return null;
- }
- set
- {
- LeftFocusableActorId = (int)value.GetId();
- }
- }
-
- /**
- * @brief The right focusable view.
- * @note This will return NULL if not set.
- * This will also return NULL if the specified right focusable view is not on stage.
- *
- */
- public View RightFocusableView
- {
- // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
- get
- {
- if (RightFocusableActorId >= 0)
- {
- return ConvertIdToView((uint)RightFocusableActorId);
- }
- return null;
- }
- set
- {
- RightFocusableActorId = (int)value.GetId();
- }
- }
-
- /**
- * @brief The up focusable view.
- * @note This will return NULL if not set.
- * This will also return NULL if the specified up focusable view is not on stage.
- *
- */
- public View UpFocusableView
- {
- // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
- get
- {
- if (UpFocusableActorId >= 0)
- {
- return ConvertIdToView((uint)UpFocusableActorId);
- }
- return null;
- }
- set
- {
- UpFocusableActorId = (int)value.GetId();
- }
- }
-
- /**
- * @brief The down focusable view.
- * @note This will return NULL if not set.
- * This will also return NULL if the specified down focusable view is not on stage.
- *
- */
- public View DownFocusableView
- {
- // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
- get
- {
- if (DownFocusableActorId >= 0)
- {
- return ConvertIdToView((uint)DownFocusableActorId);
- }
- return null;
- }
- set
- {
- DownFocusableActorId = (int)value.GetId();
- }
- }
-}
+ internal HoverSignal HoveredSignal()
+ {
+ HoverSignal ret = new HoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal WheelSignal WheelEventSignal()
+ {
+ WheelSignal ret = new WheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public ViewSignal OnWindowSignal()
+ {
+ ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public ViewSignal OffStageSignal()
+ {
+ ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public ViewSignal OnRelayoutSignal()
+ {
+ ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Vector3 ParentOrigin
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.PARENT_ORIGIN).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.PARENT_ORIGIN, new Dali.Property.Value(value));
+ }
+ }
+
+ public float ParentOriginX
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.PARENT_ORIGIN_X).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.PARENT_ORIGIN_X, new Dali.Property.Value(value));
+ }
+ }
+
+ public float ParentOriginY
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.PARENT_ORIGIN_Y).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.PARENT_ORIGIN_Y, new Dali.Property.Value(value));
+ }
+ }
+
+ public float ParentOriginZ
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.PARENT_ORIGIN_Z).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.PARENT_ORIGIN_Z, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector3 AnchorPoint
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.ANCHOR_POINT).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.ANCHOR_POINT, new Dali.Property.Value(value));
+ }
+ }
+
+ public float AnchorPointX
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.ANCHOR_POINT_X).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.ANCHOR_POINT_X, new Dali.Property.Value(value));
+ }
+ }
+
+ public float AnchorPointY
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.ANCHOR_POINT_Y).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.ANCHOR_POINT_Y, new Dali.Property.Value(value));
+ }
+ }
+
+ public float AnchorPointZ
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.ANCHOR_POINT_Z).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.ANCHOR_POINT_Z, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector3 Size
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.SIZE).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE, new Dali.Property.Value(value));
+ }
+ }
+
+ public float SizeWidth
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SIZE_WIDTH).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE_WIDTH, new Dali.Property.Value(value));
+ }
+ }
+
+ public float SizeHeight
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SIZE_HEIGHT).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE_HEIGHT, new Dali.Property.Value(value));
+ }
+ }
+
+ public float SizeDepth
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SIZE_DEPTH).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE_DEPTH, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector3 Position
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.POSITION).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION, new Dali.Property.Value(value));
+ }
+ }
+
+ public float PositionX
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.POSITION_X).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION_X, new Dali.Property.Value(value));
+ }
+ }
+
+ public float PositionY
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.POSITION_Y).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION_Y, new Dali.Property.Value(value));
+ }
+ }
+
+ public float PositionZ
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.POSITION_Z).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION_Z, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector3 WorldPosition
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.WORLD_POSITION).Get(temp);
+ return temp;
+ }
+ }
+
+ public float WorldPositionX
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.WORLD_POSITION_X).Get(ref temp);
+ return temp;
+ }
+ }
+
+ public float WorldPositionY
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.WORLD_POSITION_Y).Get(ref temp);
+ return temp;
+ }
+ }
+
+ public float WorldPositionZ
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.WORLD_POSITION_Z).Get(ref temp);
+ return temp;
+ }
+ }
+
+ public Rotation Orientation
+ {
+ get
+ {
+ Rotation temp = new Rotation();
+ GetProperty(View.Property.ORIENTATION).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.ORIENTATION, new Dali.Property.Value(value));
+ }
+ }
+
+ public Rotation WorldOrientation
+ {
+ get
+ {
+ Rotation temp = new Rotation();
+ GetProperty(View.Property.WORLD_ORIENTATION).Get(temp);
+ return temp;
+ }
+ }
+
+ public Vector3 Scale
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.SCALE).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SCALE, new Dali.Property.Value(value));
+ }
+ }
+
+ public float ScaleX
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SCALE_X).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SCALE_X, new Dali.Property.Value(value));
+ }
+ }
+
+ public float ScaleY
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SCALE_Y).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SCALE_Y, new Dali.Property.Value(value));
+ }
+ }
+
+ public float ScaleZ
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SCALE_Z).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SCALE_Z, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector3 WorldScale
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.WORLD_SCALE).Get(temp);
+ return temp;
+ }
+ }
+
+ public bool Visible
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.VISIBLE).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.VISIBLE, new Dali.Property.Value(value));
+ }
+ }
+
+ public float ColorRed
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.COLOR_RED).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.COLOR_RED, new Dali.Property.Value(value));
+ }
+ }
+
+ public float ColorGreen
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.COLOR_GREEN).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.COLOR_GREEN, new Dali.Property.Value(value));
+ }
+ }
+
+ public float ColorBlue
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.COLOR_BLUE).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.COLOR_BLUE, new Dali.Property.Value(value));
+ }
+ }
+
+ public float ColorAlpha
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.COLOR_ALPHA).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.COLOR_ALPHA, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector4 WorldColor
+ {
+ get
+ {
+ Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.WORLD_COLOR).Get(temp);
+ return temp;
+ }
+ }
+
+ public Matrix WorldMatrix
+ {
+ get
+ {
+ Matrix temp = new Matrix();
+ GetProperty(View.Property.WORLD_MATRIX).Get(temp);
+ return temp;
+ }
+ }
+
+ public string Name
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.NAME).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.NAME, new Dali.Property.Value(value));
+ }
+ }
+
+ public bool Sensitive
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.SENSITIVE).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SENSITIVE, new Dali.Property.Value(value));
+ }
+ }
+
+ public bool LeaveRequired
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.LEAVE_REQUIRED).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.LEAVE_REQUIRED, new Dali.Property.Value(value));
+ }
+ }
+
+ public bool InheritOrientation
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.INHERIT_ORIENTATION).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.INHERIT_ORIENTATION, new Dali.Property.Value(value));
+ }
+ }
+
+ public bool InheritScale
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.INHERIT_SCALE).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.INHERIT_SCALE, new Dali.Property.Value(value));
+ }
+ }
+
+ public string ColorMode
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.COLOR_MODE).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.COLOR_MODE, new Dali.Property.Value(value));
+ }
+ }
+
+ public string PositionInheritance
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.POSITION_INHERITANCE).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION_INHERITANCE, new Dali.Property.Value(value));
+ }
+ }
+
+ public string DrawMode
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.DRAW_MODE).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.DRAW_MODE, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector3 SizeModeFactor
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.SIZE_MODE_FACTOR).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE_MODE_FACTOR, new Dali.Property.Value(value));
+ }
+ }
+
+ public string WidthResizePolicy
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.WIDTH_RESIZE_POLICY).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.WIDTH_RESIZE_POLICY, new Dali.Property.Value(value));
+ }
+ }
+
+ public string HeightResizePolicy
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.HEIGHT_RESIZE_POLICY).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.HEIGHT_RESIZE_POLICY, new Dali.Property.Value(value));
+ }
+ }
+
+ public string SizeScalePolicy
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.SIZE_SCALE_POLICY).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE_SCALE_POLICY, new Dali.Property.Value(value));
+ }
+ }
+
+ public bool WidthForHeight
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.WIDTH_FOR_HEIGHT).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.WIDTH_FOR_HEIGHT, new Dali.Property.Value(value));
+ }
+ }
+
+ public bool HeightForWidth
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.HEIGHT_FOR_WIDTH).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.HEIGHT_FOR_WIDTH, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector4 Padding
+ {
+ get
+ {
+ Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.PADDING).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.PADDING, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector2 MinimumSize
+ {
+ get
+ {
+ Vector2 temp = new Vector2(0.0f, 0.0f);
+ GetProperty(View.Property.MINIMUM_SIZE).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.MINIMUM_SIZE, new Dali.Property.Value(value));
+ }
+ }
+
+ public Vector2 MaximumSize
+ {
+ get
+ {
+ Vector2 temp = new Vector2(0.0f, 0.0f);
+ GetProperty(View.Property.MAXIMUM_SIZE).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.MAXIMUM_SIZE, new Dali.Property.Value(value));
+ }
+ }
+
+ public bool InheritPosition
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.INHERIT_POSITION).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.INHERIT_POSITION, new Dali.Property.Value(value));
+ }
+ }
+ public string ClippingMode
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.CLIPPING_MODE).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.CLIPPING_MODE, new Dali.Property.Value(value));
+ }
+ }
+ }
}
namespace Dali {
-public class ActorContainer : global::System.IDisposable, global::System.Collections.IEnumerable
- , global::System.Collections.Generic.IEnumerable<Actor>
+public class ViewContainer : global::System.IDisposable, global::System.Collections.IEnumerable
+ , global::System.Collections.Generic.IEnumerable<View>
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal ActorContainer(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ internal ViewContainer(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ActorContainer obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ViewContainer obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~ActorContainer() {
+ ~ViewContainer() {
DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
- public ActorContainer(global::System.Collections.ICollection c) : this() {
+ public ViewContainer(global::System.Collections.ICollection c) : this() {
if (c == null)
throw new global::System.ArgumentNullException("c");
- foreach (Actor element in c) {
+ foreach (View element in c) {
this.Add(element);
}
}
}
}
- public Actor this[int index] {
+ public View this[int index] {
get {
return getitem(index);
}
}
}
- public void CopyTo(Actor[] array)
+ public void CopyTo(View[] array)
{
CopyTo(0, array, 0, this.Count);
}
- public void CopyTo(Actor[] array, int arrayIndex)
+ public void CopyTo(View[] array, int arrayIndex)
{
CopyTo(0, array, arrayIndex, this.Count);
}
- public void CopyTo(int index, Actor[] array, int arrayIndex, int count)
+ public void CopyTo(int index, View[] array, int arrayIndex, int count)
{
if (array == null)
throw new global::System.ArgumentNullException("array");
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
- global::System.Collections.Generic.IEnumerator<Actor> global::System.Collections.Generic.IEnumerable<Actor>.GetEnumerator() {
- return new ActorContainerEnumerator(this);
+ global::System.Collections.Generic.IEnumerator<View> global::System.Collections.Generic.IEnumerable<View>.GetEnumerator() {
+ return new ViewContainerEnumerator(this);
}
global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() {
- return new ActorContainerEnumerator(this);
+ return new ViewContainerEnumerator(this);
}
- public ActorContainerEnumerator GetEnumerator() {
- return new ActorContainerEnumerator(this);
+ public ViewContainerEnumerator GetEnumerator() {
+ return new ViewContainerEnumerator(this);
}
// Type-safe enumerator
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
- public sealed class ActorContainerEnumerator : global::System.Collections.IEnumerator
- , global::System.Collections.Generic.IEnumerator<Actor>
+ public sealed class ViewContainerEnumerator : global::System.Collections.IEnumerator
+ , global::System.Collections.Generic.IEnumerator<View>
{
- private ActorContainer collectionRef;
+ private ViewContainer collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
- public ActorContainerEnumerator(ActorContainer collection) {
+ public ViewContainerEnumerator(ViewContainer collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
}
// Type-safe iterator Current
- public Actor Current {
+ public View Current {
get {
if (currentIndex == -1)
throw new global::System.InvalidOperationException("Enumeration not started.");
throw new global::System.InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new global::System.InvalidOperationException("Collection modified.");
- return (Actor)currentObject;
+ return (View)currentObject;
}
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void Add(Actor x) {
- NDalicPINVOKE.ActorContainer_Add(swigCPtr, Actor.getCPtr(x));
+ public void Add(View x) {
+ NDalicPINVOKE.ActorContainer_Add(swigCPtr, View.getCPtr(x));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public ActorContainer() : this(NDalicPINVOKE.new_ActorContainer__SWIG_0(), true) {
+ public ViewContainer() : this(NDalicPINVOKE.new_ActorContainer__SWIG_0(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public ActorContainer(ActorContainer other) : this(NDalicPINVOKE.new_ActorContainer__SWIG_1(ActorContainer.getCPtr(other)), true) {
+ public ViewContainer(ViewContainer other) : this(NDalicPINVOKE.new_ActorContainer__SWIG_1(ViewContainer.getCPtr(other)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public ActorContainer(int capacity) : this(NDalicPINVOKE.new_ActorContainer__SWIG_2(capacity), true) {
+ public ViewContainer(int capacity) : this(NDalicPINVOKE.new_ActorContainer__SWIG_2(capacity), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- private Actor getitemcopy(int index) {
- Actor ret = new Actor(NDalicPINVOKE.ActorContainer_getitemcopy(swigCPtr, index), true);
+ private View getitemcopy(int index) {
+ View ret = new View(NDalicPINVOKE.ActorContainer_getitemcopy(swigCPtr, index), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- private Actor getitem(int index) {
- Actor ret = new Actor(NDalicPINVOKE.ActorContainer_getitem(swigCPtr, index), false);
+ private View getitem(int index) {
+ View ret = new View(NDalicPINVOKE.ActorContainer_getitem(swigCPtr, index), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- private void setitem(int index, Actor val) {
- NDalicPINVOKE.ActorContainer_setitem(swigCPtr, index, Actor.getCPtr(val));
+ private void setitem(int index, View val) {
+ NDalicPINVOKE.ActorContainer_setitem(swigCPtr, index, View.getCPtr(val));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void AddRange(ActorContainer values) {
- NDalicPINVOKE.ActorContainer_AddRange(swigCPtr, ActorContainer.getCPtr(values));
+ public void AddRange(ViewContainer values) {
+ NDalicPINVOKE.ActorContainer_AddRange(swigCPtr, ViewContainer.getCPtr(values));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public ActorContainer GetRange(int index, int count) {
+ public ViewContainer GetRange(int index, int count) {
global::System.IntPtr cPtr = NDalicPINVOKE.ActorContainer_GetRange(swigCPtr, index, count);
- ActorContainer ret = (cPtr == global::System.IntPtr.Zero) ? null : new ActorContainer(cPtr, true);
+ ViewContainer ret = (cPtr == global::System.IntPtr.Zero) ? null : new ViewContainer(cPtr, true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public void Insert(int index, Actor x) {
- NDalicPINVOKE.ActorContainer_Insert(swigCPtr, index, Actor.getCPtr(x));
+ public void Insert(int index, View x) {
+ NDalicPINVOKE.ActorContainer_Insert(swigCPtr, index, View.getCPtr(x));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void InsertRange(int index, ActorContainer values) {
- NDalicPINVOKE.ActorContainer_InsertRange(swigCPtr, index, ActorContainer.getCPtr(values));
+ public void InsertRange(int index, ViewContainer values) {
+ NDalicPINVOKE.ActorContainer_InsertRange(swigCPtr, index, ViewContainer.getCPtr(values));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static ActorContainer Repeat(Actor value, int count) {
- global::System.IntPtr cPtr = NDalicPINVOKE.ActorContainer_Repeat(Actor.getCPtr(value), count);
- ActorContainer ret = (cPtr == global::System.IntPtr.Zero) ? null : new ActorContainer(cPtr, true);
+ public static ViewContainer Repeat(View value, int count) {
+ global::System.IntPtr cPtr = NDalicPINVOKE.ActorContainer_Repeat(View.getCPtr(value), count);
+ ViewContainer ret = (cPtr == global::System.IntPtr.Zero) ? null : new ViewContainer(cPtr, true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetRange(int index, ActorContainer values) {
- NDalicPINVOKE.ActorContainer_SetRange(swigCPtr, index, ActorContainer.getCPtr(values));
+ public void SetRange(int index, ViewContainer values) {
+ NDalicPINVOKE.ActorContainer_SetRange(swigCPtr, index, ViewContainer.getCPtr(values));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- protected virtual new void OnChildAdd(Actor child) {
- if (SwigDerivedClassHasMethod("OnChildAdd", swigMethodTypes2)) NDalicPINVOKE.ViewImpl_OnChildAddSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnChildAdd(swigCPtr, Actor.getCPtr(child));
+ protected virtual new void OnChildAdd(View child) {
+ if (SwigDerivedClassHasMethod("OnChildAdd", swigMethodTypes2)) NDalicPINVOKE.ViewImpl_OnChildAddSwigExplicitViewImpl(swigCPtr, View.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnChildAdd(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- protected virtual new void OnChildRemove(Actor child) {
- if (SwigDerivedClassHasMethod("OnChildRemove", swigMethodTypes3)) NDalicPINVOKE.ViewImpl_OnChildRemoveSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnChildRemove(swigCPtr, Actor.getCPtr(child));
+ protected virtual new void OnChildRemove(View child) {
+ if (SwigDerivedClassHasMethod("OnChildRemove", swigMethodTypes3)) NDalicPINVOKE.ViewImpl_OnChildRemoveSwigExplicitViewImpl(swigCPtr, View.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnChildRemove(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
return ret;
}
- protected virtual new float CalculateChildSize(Actor child, DimensionType dimension) {
- float ret = (SwigDerivedClassHasMethod("CalculateChildSize", swigMethodTypes14) ? NDalicPINVOKE.ViewImpl_CalculateChildSizeSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(child), (int)dimension) : NDalicPINVOKE.ViewImpl_CalculateChildSize(swigCPtr, Actor.getCPtr(child), (int)dimension));
+ protected virtual new float CalculateChildSize(View child, DimensionType dimension) {
+ float ret = (SwigDerivedClassHasMethod("CalculateChildSize", swigMethodTypes14) ? NDalicPINVOKE.ViewImpl_CalculateChildSizeSwigExplicitViewImpl(swigCPtr, View.getCPtr(child), (int)dimension) : NDalicPINVOKE.ViewImpl_CalculateChildSize(swigCPtr, View.getCPtr(child), (int)dimension));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public virtual void OnControlChildAdd(Actor child) {
- if (SwigDerivedClassHasMethod("OnControlChildAdd", swigMethodTypes22)) NDalicPINVOKE.ViewImpl_OnControlChildAddSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnControlChildAdd(swigCPtr, Actor.getCPtr(child));
+ public virtual void OnControlChildAdd(View child) {
+ if (SwigDerivedClassHasMethod("OnControlChildAdd", swigMethodTypes22)) NDalicPINVOKE.ViewImpl_OnControlChildAddSwigExplicitViewImpl(swigCPtr, View.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnControlChildAdd(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public virtual void OnControlChildRemove(Actor child) {
- if (SwigDerivedClassHasMethod("OnControlChildRemove", swigMethodTypes23)) NDalicPINVOKE.ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnControlChildRemove(swigCPtr, Actor.getCPtr(child));
+ public virtual void OnControlChildRemove(View child) {
+ if (SwigDerivedClassHasMethod("OnControlChildRemove", swigMethodTypes23)) NDalicPINVOKE.ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(swigCPtr, View.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnControlChildRemove(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public virtual Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, View.KeyboardFocus.Direction direction, bool loopEnabled) {
- Actor ret = new Actor((SwigDerivedClassHasMethod("GetNextKeyboardFocusableActor", swigMethodTypes32) ? NDalicPINVOKE.ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(currentFocusedActor), (int)direction, loopEnabled) : NDalicPINVOKE.ViewImpl_GetNextKeyboardFocusableActor(swigCPtr, Actor.getCPtr(currentFocusedActor), (int)direction, loopEnabled)), true);
+ public virtual View GetNextKeyboardFocusableView(View currentFocusedView, View.KeyboardFocus.Direction direction, bool loopEnabled) {
+ View ret = new View((SwigDerivedClassHasMethod("GetNextKeyboardFocusableView", swigMethodTypes32) ? NDalicPINVOKE.ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(swigCPtr, View.getCPtr(currentFocusedView), (int)direction, loopEnabled) : NDalicPINVOKE.ViewImpl_GetNextKeyboardFocusableActor(swigCPtr, View.getCPtr(currentFocusedView), (int)direction, loopEnabled)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public virtual void OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor) {
- if (SwigDerivedClassHasMethod("OnKeyboardFocusChangeCommitted", swigMethodTypes33)) NDalicPINVOKE.ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(commitedFocusableActor)); else NDalicPINVOKE.ViewImpl_OnKeyboardFocusChangeCommitted(swigCPtr, Actor.getCPtr(commitedFocusableActor));
+ public virtual void OnKeyboardFocusChangeCommitted(View commitedFocusableView) {
+ if (SwigDerivedClassHasMethod("OnKeyboardFocusChangeCommitted", swigMethodTypes33)) NDalicPINVOKE.ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(swigCPtr, View.getCPtr(commitedFocusableView)); else NDalicPINVOKE.ViewImpl_OnKeyboardFocusChangeCommitted(swigCPtr, View.getCPtr(commitedFocusableView));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
swigDelegate30 = new SwigDelegateViewImpl_30(SwigDirectorOnKeyInputFocusGained);
if (SwigDerivedClassHasMethod("OnKeyInputFocusLost", swigMethodTypes31))
swigDelegate31 = new SwigDelegateViewImpl_31(SwigDirectorOnKeyInputFocusLost);
- if (SwigDerivedClassHasMethod("GetNextKeyboardFocusableActor", swigMethodTypes32))
- swigDelegate32 = new SwigDelegateViewImpl_32(SwigDirectorGetNextKeyboardFocusableActor);
+ if (SwigDerivedClassHasMethod("GetNextKeyboardFocusableView", swigMethodTypes32))
+ swigDelegate32 = new SwigDelegateViewImpl_32(SwigDirectorGetNextKeyboardFocusableView);
if (SwigDerivedClassHasMethod("OnKeyboardFocusChangeCommitted", swigMethodTypes33))
swigDelegate33 = new SwigDelegateViewImpl_33(SwigDirectorOnKeyboardFocusChangeCommitted);
if (SwigDerivedClassHasMethod("OnKeyboardEnter", swigMethodTypes34))
}
private void SwigDirectorOnChildAdd(global::System.IntPtr child) {
- OnChildAdd(new Actor(child, false));
+ OnChildAdd(new View(child, false));
}
private void SwigDirectorOnChildRemove(global::System.IntPtr child) {
- OnChildRemove(new Actor(child, false));
+ OnChildRemove(new View(child, false));
}
private void SwigDirectorOnPropertySet(int index, global::System.IntPtr propertyValue) {
}
private float SwigDirectorCalculateChildSize(global::System.IntPtr child, int dimension) {
- return CalculateChildSize(new Actor(child, false), (DimensionType)dimension);
+ return CalculateChildSize(new View(child, false), (DimensionType)dimension);
}
private float SwigDirectorGetHeightForWidth(float width) {
}
private void SwigDirectorOnControlChildAdd(global::System.IntPtr child) {
- OnControlChildAdd(new Actor(child, false));
+ OnControlChildAdd(new View(child, false));
}
private void SwigDirectorOnControlChildRemove(global::System.IntPtr child) {
- OnControlChildRemove(new Actor(child, false));
+ OnControlChildRemove(new View(child, false));
}
private void SwigDirectorOnStyleChange(global::System.IntPtr styleManager, int change) {
OnKeyInputFocusLost();
}
- private global::System.IntPtr SwigDirectorGetNextKeyboardFocusableActor(global::System.IntPtr currentFocusedActor, int direction, bool loopEnabled) {
- return Actor.getCPtr(GetNextKeyboardFocusableActor(new Actor(currentFocusedActor, true), (View.KeyboardFocus.Direction)direction, loopEnabled)).Handle;
+ private global::System.IntPtr SwigDirectorGetNextKeyboardFocusableView(global::System.IntPtr currentFocusedView, int direction, bool loopEnabled) {
+ return View.getCPtr(GetNextKeyboardFocusableView(new View(currentFocusedView, true), (View.KeyboardFocus.Direction)direction, loopEnabled)).Handle;
}
- private void SwigDirectorOnKeyboardFocusChangeCommitted(global::System.IntPtr commitedFocusableActor) {
- OnKeyboardFocusChangeCommitted(new Actor(commitedFocusableActor, true));
+ private void SwigDirectorOnKeyboardFocusChangeCommitted(global::System.IntPtr commitedFocusableView) {
+ OnKeyboardFocusChangeCommitted(new View(commitedFocusableView, true));
}
private bool SwigDirectorOnKeyboardEnter() {
private static global::System.Type[] swigMethodTypes0 = new global::System.Type[] { typeof(int) };
private static global::System.Type[] swigMethodTypes1 = new global::System.Type[] { };
- private static global::System.Type[] swigMethodTypes2 = new global::System.Type[] { typeof(Actor) };
- private static global::System.Type[] swigMethodTypes3 = new global::System.Type[] { typeof(Actor) };
+ private static global::System.Type[] swigMethodTypes2 = new global::System.Type[] { typeof(View) };
+ private static global::System.Type[] swigMethodTypes3 = new global::System.Type[] { typeof(View) };
private static global::System.Type[] swigMethodTypes4 = new global::System.Type[] { typeof(int), typeof(Property.Value) };
private static global::System.Type[] swigMethodTypes5 = new global::System.Type[] { typeof(Vector3) };
private static global::System.Type[] swigMethodTypes6 = new global::System.Type[] { typeof(Animation), typeof(Vector3) };
private static global::System.Type[] swigMethodTypes11 = new global::System.Type[] { typeof(Vector2), typeof(RelayoutContainer) };
private static global::System.Type[] swigMethodTypes12 = new global::System.Type[] { typeof(ResizePolicyType), typeof(DimensionType) };
private static global::System.Type[] swigMethodTypes13 = new global::System.Type[] { };
- private static global::System.Type[] swigMethodTypes14 = new global::System.Type[] { typeof(Actor), typeof(DimensionType) };
+ private static global::System.Type[] swigMethodTypes14 = new global::System.Type[] { typeof(View), typeof(DimensionType) };
private static global::System.Type[] swigMethodTypes15 = new global::System.Type[] { typeof(float) };
private static global::System.Type[] swigMethodTypes16 = new global::System.Type[] { typeof(float) };
private static global::System.Type[] swigMethodTypes17 = new global::System.Type[] { typeof(DimensionType) };
private static global::System.Type[] swigMethodTypes19 = new global::System.Type[] { typeof(DimensionType) };
private static global::System.Type[] swigMethodTypes20 = new global::System.Type[] { typeof(float), typeof(DimensionType) };
private static global::System.Type[] swigMethodTypes21 = new global::System.Type[] { };
- private static global::System.Type[] swigMethodTypes22 = new global::System.Type[] { typeof(Actor) };
- private static global::System.Type[] swigMethodTypes23 = new global::System.Type[] { typeof(Actor) };
+ private static global::System.Type[] swigMethodTypes22 = new global::System.Type[] { typeof(View) };
+ private static global::System.Type[] swigMethodTypes23 = new global::System.Type[] { typeof(View) };
private static global::System.Type[] swigMethodTypes24 = new global::System.Type[] { typeof(StyleManager), typeof(StyleChangeType) };
private static global::System.Type[] swigMethodTypes25 = new global::System.Type[] { };
private static global::System.Type[] swigMethodTypes26 = new global::System.Type[] { typeof(PanGesture) };
private static global::System.Type[] swigMethodTypes29 = new global::System.Type[] { };
private static global::System.Type[] swigMethodTypes30 = new global::System.Type[] { };
private static global::System.Type[] swigMethodTypes31 = new global::System.Type[] { };
- private static global::System.Type[] swigMethodTypes32 = new global::System.Type[] { typeof(Actor), typeof(View.KeyboardFocus.Direction), typeof(bool) };
- private static global::System.Type[] swigMethodTypes33 = new global::System.Type[] { typeof(Actor) };
+ private static global::System.Type[] swigMethodTypes32 = new global::System.Type[] { typeof(View), typeof(View.KeyboardFocus.Direction), typeof(bool) };
+ private static global::System.Type[] swigMethodTypes33 = new global::System.Type[] { typeof(View) };
private static global::System.Type[] swigMethodTypes34 = new global::System.Type[] { };
private static global::System.Type[] swigMethodTypes35 = new global::System.Type[] { typeof(PinchGesture) };
private static global::System.Type[] swigMethodTypes36 = new global::System.Type[] { typeof(PanGesture) };
{
// Create the control
CustomView newControl = controlConstructor ();
- return newControl.GetPtrfromActor(); // return pointer to handle
+ return newControl.GetPtrfromView(); // return pointer to handle
}
else
{
}
}
- public static View GetViewFromActor( Actor actor )
+ public static View GetViewFromActor( View view )
{
// we store a dictionary of ref-obects (C++ land) to custom views (C# land)
- RefObject refObj = actor.GetObjectPtr ();
+ RefObject refObj = view.GetObjectPtr ();
IntPtr refObjectPtr = (IntPtr) RefObject.getCPtr(refObj);
WeakReference viewReference;
if ( Instance._controlMap.TryGetValue ( refObjectPtr, out viewReference) )
{
- View view = viewReference.Target as View;
- return view;
+ View retview = viewReference.Target as View;
+ return retview;
}
else
{
namespace Dali {
-public class ActorSignal : global::System.IDisposable {
+public class ViewSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal ActorSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ internal ViewSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ActorSignal obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ViewSignal obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~ActorSignal() {
+ ~ViewSignal() {
DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg) {
- NDalicPINVOKE.ActorSignal_Emit(swigCPtr, Actor.getCPtr(arg));
+ public void Emit(View arg) {
+ NDalicPINVOKE.ActorSignal_Emit(swigCPtr, View.getCPtr(arg));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public ActorSignal() : this(NDalicPINVOKE.new_ActorSignal(), true) {
+ public ViewSignal() : this(NDalicPINVOKE.new_ActorSignal(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
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 OnChildAddDelegate(View view);
+ public delegate void OnChildRemoveDelegate(View view);
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 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 CalculateChildSizeDelegate(View 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 OnControlChildAddDelegate(View child);
+ public delegate void OnControlChildRemoveDelegate(View child);
public delegate void OnStyleChangeDelegate(StyleManager styleManager, StyleChangeType change);
public delegate bool OnAccessibilityActivatedDelegate();
public delegate bool OnAccessibilityPanDelegate(PanGesture gestures);
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 View GetNextKeyboardFocusableActorDelegate(View currentFocusedActor, View.KeyboardFocus.Direction direction, bool loopEnabled);
+ public delegate void OnKeyboardFocusChangeCommittedDelegate(View commitedFocusableActor);
public delegate bool OnKeyboardEnterDelegate();
public delegate void OnPinchDelegate(PinchGesture pinch);
public delegate void OnPanDelegate(PanGesture pan);
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
return ret;
}
- public float CalculateChildSizeBase(Actor child, DimensionType dimension)
+ public float CalculateChildSizeBase(View child, DimensionType dimension)
{
- float ret = NDalicManualPINVOKE.ViewWrapperImpl_CalculateChildSizeBase(swigCPtr, Actor.getCPtr(child), (int)dimension);
+ float ret = NDalicManualPINVOKE.ViewWrapperImpl_CalculateChildSizeBase(swigCPtr, View.getCPtr(child), (int)dimension);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void DirectorOnChildAdd(global::System.IntPtr child)
{
- OnChildAdd(new Actor(child, false));
+ OnChildAdd(new View(child, false));
}
private void DirectorOnChildRemove(global::System.IntPtr child)
{
- OnChildRemove(new Actor(child, false));
+ OnChildRemove(new View(child, false));
}
private void DirectorOnPropertySet(int index, global::System.IntPtr propertyValue)
private float DirectorCalculateChildSize(global::System.IntPtr child, int dimension)
{
- return CalculateChildSize(new Actor(child, false), (DimensionType)dimension);
+ return CalculateChildSize(new View(child, false), (DimensionType)dimension);
}
private float DirectorGetHeightForWidth(float width)
private void DirectorOnControlChildAdd(global::System.IntPtr child)
{
- OnControlChildAdd(new Actor(child, false));
+ OnControlChildAdd(new View(child, false));
}
private void DirectorOnControlChildRemove(global::System.IntPtr child)
{
- OnControlChildRemove(new Actor(child, false));
+ OnControlChildRemove(new View(child, false));
}
private void DirectorOnStyleChange(global::System.IntPtr styleManager, int change)
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;
+ return View.getCPtr(GetNextKeyboardFocusableActor(new View(currentFocusedActor, false), (View.KeyboardFocus.Direction)direction, loopEnabled)).Handle;
}
private void DirectorOnKeyboardFocusChangeCommitted(global::System.IntPtr commitedFocusableActor)
{
- OnKeyboardFocusChangeCommitted(new Actor(commitedFocusableActor, false));
+ OnKeyboardFocusChangeCommitted(new View(commitedFocusableActor, false));
}
private bool DirectorOnKeyboardEnter()
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
namespace Dali {
-public class ActorWheelSignal : global::System.IDisposable {
+internal class WheelSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal ActorWheelSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ internal WheelSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ActorWheelSignal obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(WheelSignal obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~ActorWheelSignal() {
+ ~WheelSignal() {
DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public bool Emit(Actor arg1, Wheel arg2) {
- bool ret = NDalicPINVOKE.ActorWheelSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Wheel.getCPtr(arg2));
+ public bool Emit(View arg1, Wheel arg2) {
+ bool ret = NDalicPINVOKE.ActorWheelSignal_Emit(swigCPtr, View.getCPtr(arg1), Wheel.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public ActorWheelSignal() : this(NDalicPINVOKE.new_ActorWheelSignal(), true) {
+ public WheelSignal() : this(NDalicPINVOKE.new_ActorWheelSignal(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public class Window : BaseHandle {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ private global::System.Runtime.InteropServices.HandleRef stageCPtr;
internal Window(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Window_SWIGUpcast(cPtr), cMemoryOwn) {
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ stageCPtr = new global::System.Runtime.InteropServices.HandleRef(this, NDalicPINVOKE.Stage_GetCurrent());
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Window obj) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
if (swigCMemOwn) {
swigCMemOwn = false;
NDalicPINVOKE.delete_Window(swigCPtr);
+ NDalicPINVOKE.delete_Stage(stageCPtr);
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
}
-
+ public static bool IsInstalled() {
+ bool ret = NDalicPINVOKE.Stage_IsInstalled();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
public void SetAcceptFocus( bool accept )
{
NDalicPINVOKE.SetAcceptFocus(swigCPtr, accept);
return ret;
}
+ public WindowFocusSignalType FocusChangedSignal() {
+ WindowFocusSignalType ret = new WindowFocusSignalType(NDalicPINVOKE.FocusChangedSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Layer GetDefaultLayer()
+ {
+ return this.GetRootLayer();
+ }
+
+ public void Add(Layer layer)
+ {
+ NDalicPINVOKE.Stage_Add(stageCPtr, Layer.getCPtr(layer));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Remove(Layer layer)
+ {
+ NDalicPINVOKE.Stage_Remove(stageCPtr, Layer.getCPtr(layer));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Add(View view) {
+ NDalicPINVOKE.Stage_Add(stageCPtr, View.getCPtr(view));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Remove(View view) {
+ NDalicPINVOKE.Stage_Remove(stageCPtr, View.getCPtr(view));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Vector2 GetSize() {
+ Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetSize(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public RenderTaskList GetRenderTaskList() {
+ RenderTaskList ret = new RenderTaskList(NDalicPINVOKE.Stage_GetRenderTaskList(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public uint GetLayerCount() {
+ uint ret = NDalicPINVOKE.Stage_GetLayerCount(stageCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Layer GetLayer(uint depth) {
+ Layer ret = new Layer(NDalicPINVOKE.Stage_GetLayer(stageCPtr, depth), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Layer GetRootLayer() {
+ Layer ret = new Layer(NDalicPINVOKE.Stage_GetRootLayer(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetBackgroundColor(Vector4 color) {
+ NDalicPINVOKE.Stage_SetBackgroundColor(stageCPtr, Vector4.getCPtr(color));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Vector4 GetBackgroundColor() {
+ Vector4 ret = new Vector4(NDalicPINVOKE.Stage_GetBackgroundColor(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Vector2 GetDpi() {
+ Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetDpi(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public ObjectRegistry GetObjectRegistry() {
+ ObjectRegistry ret = new ObjectRegistry(NDalicPINVOKE.Stage_GetObjectRegistry(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void KeepRendering(float durationSeconds) {
+ NDalicPINVOKE.Stage_KeepRendering(stageCPtr, durationSeconds);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public KeyEventSignal KeyEventSignal() {
+ KeyEventSignal ret = new KeyEventSignal(NDalicPINVOKE.Stage_KeyEventSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public VoidSignal EventProcessingFinishedSignal() {
+ VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_EventProcessingFinishedSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public TouchSignal TouchSignal() {
+ TouchSignal ret = new TouchSignal(NDalicPINVOKE.Stage_TouchSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ private StageWheelSignal WheelEventSignal() {
+ StageWheelSignal ret = new StageWheelSignal(NDalicPINVOKE.Stage_WheelEventSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public VoidSignal ContextLostSignal() {
+ VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextLostSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public VoidSignal ContextRegainedSignal() {
+ VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextRegainedSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public VoidSignal SceneCreatedSignal() {
+ VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_SceneCreatedSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public static Vector4 DEFAULT_BACKGROUND_COLOR {
+ get {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEFAULT_BACKGROUND_COLOR_get();
+ Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ public static Vector4 DEBUG_BACKGROUND_COLOR {
+ get {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEBUG_BACKGROUND_COLOR_get();
+ Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ private static readonly Window instance = Application.Instance.GetWindow();
+ public static Window Instance
+ {
+ get
+ {
+ return instance;
+ }
+ }
+
public enum WindowOrientation {
PORTRAIT = 0,
LANDSCAPE = 90,
AUTO = 2
}
+
+
+ /**
+ * @brief Event arguments that passed via Touch signal
+ *
+ */
+ public class TouchEventArgs : EventArgs
+ {
+ private Touch _touch;
+
+ /**
+ * @brief Touch - contains the information of touch points
+ *
+ */
+ public Touch Touch
+ {
+ get
+ {
+ return _touch;
+ }
+ set
+ {
+ _touch = value;
+ }
+ }
+ }
+
+ private event EventHandler<TouchEventArgs> _stageTouchHandler;
+ private EventCallbackDelegateType1<IntPtr> _stageTouchCallbackDelegate;
+
+ /**
+ * @brief Event for TouchEvent signal which can be used to subscribe/unsubscribe the event handler
+ * TouchEvent signal is emitted when the screen is touched and when the touch ends
+ * (i.e. the down & up touch events only).
+ *
+ */
+ public event EventHandler<TouchEventArgs> Touch
+ {
+ add
+ {
+ lock(this)
+ {
+ _stageTouchHandler += value;
+ _stageTouchCallbackDelegate = OnStageTouch;
+ this.TouchSignal().Connect(_stageTouchCallbackDelegate);
+ }
+ }
+ remove
+ {
+ lock(this)
+ {
+ if (_stageTouchHandler != null)
+ {
+ this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
+ }
+ _stageTouchHandler -= value;
+ }
+ }
+ }
+
+ private void OnStageTouch(IntPtr data)
+ {
+ TouchEventArgs e = new TouchEventArgs();
+
+ if( data != null )
+ {
+ e.Touch = Dali.Touch.GetTouchFromPtr( data );
+ }
+
+ if (_stageTouchHandler != null)
+ {
+ _stageTouchHandler(this, e);
+ }
+ }
+
+ /**
+ * @brief Wheel arguments that passed via Wheel signal
+ *
+ */
+ public class WheelEventArgs : EventArgs
+ {
+ private Wheel _wheel;
+
+ /**
+ * @brief Wheel - store a wheel rolling type MOUSE_WHEEL or CUSTOM_WHEEL
+ *
+ */
+ public Wheel Wheel
+ {
+ get
+ {
+ return _wheel;
+ }
+ set
+ {
+ _wheel = value;
+ }
+ }
+ }
+
+ private event EventHandler<WheelEventArgs> _stageWheelHandler;
+ private EventCallbackDelegateType1<IntPtr> _stageWheelCallbackDelegate;
+
+ /**
+ * @brief Event for Wheel signal which can be used to subscribe/unsubscribe the event handler
+ * Wheel signal is emitted is emitted when wheel event is received.
+ *
+ */
+ public event EventHandler<WheelEventArgs> Wheel
+ {
+ add
+ {
+ lock(this)
+ {
+ _stageWheelHandler += value;
+ _stageWheelCallbackDelegate = OnStageWheel;
+ this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
+ }
+ }
+ remove
+ {
+ lock(this)
+ {
+ if (_stageWheelHandler != null)
+ {
+ this.WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
+ }
+ _stageWheelHandler -= value;
+ }
+ }
+ }
+
+ private void OnStageWheel(IntPtr data)
+ {
+ WheelEventArgs e = new WheelEventArgs();
+
+ if( data != null )
+ {
+ e.Wheel = Dali.Wheel.GetWheelFromPtr( data );
+ }
+
+ if (_stageWheelHandler != null)
+ {
+ _stageWheelHandler(this, e);
+ }
+ }
+
+ /**
+ * @brief Event arguments that passed via Key signal
+ *
+ */
+ public class KeyEventArgs : EventArgs
+ {
+ private Key _key;
+
+ /**
+ * @brief Key - is the keyevent sent to Stage.
+ *
+ */
+ public Key Key
+ {
+ get
+ {
+ return _key;
+ }
+ set
+ {
+ _key = value;
+ }
+ }
+ }
+
+ private event EventHandler<KeyEventArgs> _stageKeyHandler;
+ private EventCallbackDelegateType1<IntPtr> _stageKeyCallbackDelegate;
+
+ /**
+ * @brief Event for Key signal which can be used to subscribe/unsubscribe the event handler
+ * Key signal is emitted is emitted when key event is received.
+ *
+ */
+ public event EventHandler<KeyEventArgs> Key
+ {
+ add
+ {
+ lock(this)
+ {
+ _stageKeyHandler += value;
+ _stageKeyCallbackDelegate = OnStageKey;
+ this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
+ }
+ }
+ remove
+ {
+ lock(this)
+ {
+ if (_stageKeyHandler != null)
+ {
+ this.KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
+ }
+ _stageKeyHandler -= value;
+ }
+ }
+ }
+
+ // Callback for Stage KeyEventsignal
+ private void OnStageKey(IntPtr data)
+ {
+ KeyEventArgs e = new KeyEventArgs();
+
+ if( data != null )
+ {
+ e.Key = Dali.Key.GetKeyFromPtr( data );
+ }
+
+ if (_stageKeyHandler != null)
+ {
+ //here we send all data to user event handlers
+ _stageKeyHandler(this, e);
+ }
+ }
+
+
+ private event EventHandler _stageEventProcessingFinishedEventHandler;
+ private EventCallbackDelegateType0 _stageEventProcessingFinishedEventCallbackDelegate;
+
+ /**
+ * @brief Event for EventProcessingFinished signal which can be used to subscribe/unsubscribe the event handler
+ * provided by the user. EventProcessingFinished signal is emitted just after the event processing is finished.
+ *
+ */
+ public event EventHandler EventProcessingFinished
+ {
+ add
+ {
+ lock(this)
+ {
+ _stageEventProcessingFinishedEventHandler += value;
+ _stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
+ this.EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
+ }
+ }
+ remove
+ {
+ lock(this)
+ {
+ if (_stageEventProcessingFinishedEventHandler != null)
+ {
+ this.EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
+ }
+ _stageEventProcessingFinishedEventHandler -= value;
+ }
+ }
+ }
+
+ // Callback for Stage EventProcessingFinishedSignal
+ private void OnEventProcessingFinished()
+ {
+ if (_stageEventProcessingFinishedEventHandler != null)
+ {
+ _stageEventProcessingFinishedEventHandler(this, null);
+ }
+ }
+
+
+ private EventHandler _stageContextLostEventHandler;
+ private EventCallbackDelegateType0 _stageContextLostEventCallbackDelegate;
+
+ /**
+ * @brief Event for ContextLost signal which can be used to subscribe/unsubscribe the event handler
+ * ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).
+ *
+ */
+ public event EventHandler ContextLost
+ {
+ add
+ {
+ lock(this)
+ {
+ _stageContextLostEventHandler += value;
+ _stageContextLostEventCallbackDelegate = OnContextLost;
+ this.ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
+ }
+ }
+ remove
+ {
+ lock(this)
+ {
+ if (_stageContextLostEventHandler != null)
+ {
+ this.ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
+ }
+
+ _stageContextLostEventHandler -= value;
+ }
+ }
+ }
+
+ // Callback for Stage ContextLostSignal
+ private void OnContextLost()
+ {
+ if (_stageContextLostEventHandler != null)
+ {
+ _stageContextLostEventHandler(this, null);
+ }
+ }
+
+
+ private EventHandler _stageContextRegainedEventHandler;
+ private EventCallbackDelegateType0 _stageContextRegainedEventCallbackDelegate;
+
+ /**
+ * @brief Event for ContextRegained signal which can be used to subscribe/unsubscribe the event handler
+ * provided by the user. ContextRegained signal is emitted when the GL context is regained (Platform specific
+ * behaviour).
+ *
+ */
+ public event EventHandler ContextRegained
+ {
+ add
+ {
+ lock(this)
+ {
+ _stageContextRegainedEventHandler += value;
+ _stageContextRegainedEventCallbackDelegate = OnContextRegained;
+ this.ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
+ }
+ }
+ remove
+ {
+ lock(this)
+ {
+ if (_stageContextRegainedEventHandler != null)
+ {
+ this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
+ }
+
+ _stageContextRegainedEventHandler -= value;
+ }
+ }
+ }
+
+ // Callback for Stage ContextRegainedSignal
+ private void OnContextRegained()
+ {
+ if (_stageContextRegainedEventHandler != null)
+ {
+ _stageContextRegainedEventHandler(this, null);
+ }
+ }
+
+
+ private EventHandler _stageSceneCreatedEventHandler;
+ private EventCallbackDelegateType0 _stageSceneCreatedEventCallbackDelegate;
+
+ /**
+ * @brief Event for SceneCreated signal which can be used to subscribe/unsubscribe the event handler
+ * SceneCreated signal is emitted after the initial scene is created.
+ *
+ */
+ public event EventHandler SceneCreated
+ {
+ add
+ {
+ lock(this)
+ {
+ _stageSceneCreatedEventHandler += value;
+ _stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
+ this.SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
+ }
+ }
+ remove
+ {
+ lock(this)
+ {
+ if (_stageSceneCreatedEventHandler != null)
+ {
+ this.SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
+ }
+
+ _stageSceneCreatedEventHandler -= value;
+ }
+ }
+ }
+
+ // Callback for Stage SceneCreatedSignal
+ private void OnSceneCreated()
+ {
+ if (_stageSceneCreatedEventHandler != null)
+ {
+ _stageSceneCreatedEventHandler(this, null);
+ }
+ }
+
+
+ public Vector2 Size
+ {
+ get
+ {
+ Vector2 ret = GetSize();
+ return ret;
+ }
+ }
+
+ public Vector4 BackgroundColor
+ {
+ set
+ {
+ SetBackgroundColor(value);
+ }
+ get
+ {
+ Vector4 ret = GetBackgroundColor();
+ return ret;
+ }
+ }
+
}
}
%rename(Y) Dali::Vector4::y;
%rename(Z) Dali::Vector4::z;
%rename(W) Dali::Vector4::w;
+%rename(VisibilityChangeType) Dali::DevelActor::VisibilityChange::Type;
typedef std::pair<std::string, Dali::Property::Value> StringValuePair;
typedef std::vector<Dali::TouchPoint> TouchPointContainer;
result = (Dali::EventThreadCallback *)new Dali::EventThreadCallback((Dali::CallbackBase *)Dali::MakeCallback(arg1));
} catch (std::out_of_range& e) {
{
+ delete result;
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
};
} catch (std::exception& e) {
{
+ delete result;
SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
};
} catch (...) {
{
+ delete result;
SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
};
}
#puts(className);
#puts(fileName);
- # Get the property information ( name, type, read/writeable)
+ # Get the property information ( name, type, read/writeable)
propertyInfo = extractToolkitPropertyInfo( macro );
# get or create a new DALi class item which stores the property information
classItem = getDaliClassItem( className )
- classItem.properties.push( propertyInfo )
+ # exclusion of control-data-impl
+ if ( className != "ControlData" )
+ classItem.properties.push( propertyInfo )
+ end
end